亲宝软件园·资讯

展开

Java行为型模式 Java设计模式之初识行为型模式

三笠·阿卡曼 人气:0
想了解Java设计模式之初识行为型模式的相关内容吗,三笠·阿卡曼在本文为您仔细讲解Java行为型模式的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:Java行为型模式,java设计模式,下面大家一起来学习吧。

一、行为型模式

二、模板方法模式

在模板模式中,一个抽象类公开定义了执行它的方法的方式模板。它的子类可以按需重写方法实现,但调用将以抽象类中定义的方式进行;

2.1 例子

以做饭举例

模板类

package com.vleus.design.behavioral.template;

/**
 * @author vleus
 * @date 2021年06月06日 15:49
 */
public abstract class CookieTemplate {

    /**
     * 定义算法:定义好的模板,关键性步骤留给子类实现
     */
    public void cook() {
        //定义算法步骤
        heating();
        addFood();
        addSalt();
        stirfry();
        end();
    }

    //加热方法
    public void heating() {
        System.out.println("准备开火。。。");
    }

    //添加食物
    public abstract void addFood();


    //加盐
    public abstract void addSalt();

    //翻炒
    public void stirfry() {
        System.out.println("翻炒中。。。");
    }

    //出锅
    public void end() {
        System.out.println("出锅。。。。");
    }

}

子类实现模板类

package com.vleus.design.behavioral.template;

/**
 * @author vleus
 * @date 2021年06月06日 15:53
 */
public class AutoCookMachine extends CookieTemplate{

    @Override
    public void addFood() {
        System.out.println("放了三根娃娃菜。。。");
    }

    @Override
    public void addSalt() {
        System.out.println("放了一勺盐。。。");
    }
}

测试类

package com.vleus.design.behavioral.template;

/**
 * @author vleus
 * @date 2021年06月06日 15:54
 */
public class MainTest {

    public static void main(String[] args) {

        AutoCookMachine autoCookMachine = new AutoCookMachine();

        autoCookMachine.cook();

    }
}

运行结果

在这里插入图片描述 

2.2 模板方法使用场景

三、策略模式

概念:策略(Strategy)模式定义了一系列算法,并将每个算法封装起来,使得它们可以相互替换,且算法的变化不会影响使用算法的客户。属于对象行为模式

3.1 例子

以RNG的打游戏的策略为例
环境类,持有策略引用

package com.vleus.design.behavioral.strategy;

/**
 * @author vleus
 * @date 2021年06月06日 16:04
 */
public class TeamRNG {

    //抽取游戏策略算法,并进行引用
    private GameStrategy gameStrategy;

    public void setGameStrategy(GameStrategy gameStrategy) {
        this.gameStrategy = gameStrategy;
    }

    public void startGame() {

        System.out.println("全军出击。。。");

        //使用游戏套路
        gameStrategy.warStrategy();

        System.out.println("Victory。。。。。");
    }
}

抽象策略类,定义相关策略方法

package com.vleus.design.behavioral.strategy;

public interface GameStrategy {

    //游戏策略方法
    void warStrategy();
}

抽象策略类的实现1

package com.vleus.design.behavioral.strategy;

/**
 * @author vleus
 * @date 2021年06月06日 16:07
 */
public class UziStrategy implements GameStrategy{
    @Override
    public void warStrategy() {
        System.out.println("uzi莽夫式打法获取胜利。。。。");
    }
}

抽象策略类的实现2

package com.vleus.design.behavioral.strategy;

/**
 * @author vleus
 * @date 2021年06月06日 16:07
 */
public class SteadyGameStrategy implements GameStrategy{

    @Override
    public void warStrategy() {
        System.out.println("稳健运营,蚕食对手获取胜利。。。");
    }
}

测试类

package com.vleus.design.behavioral.strategy;

/**
 * @author vleus
 * @date 2021年06月06日 16:08
 */
public class MainTest {

    public static void main(String[] args) {
        TeamRNG teamRNG = new TeamRNG();

        teamRNG.setGameStrategy(new UziStrategy());

        teamRNG.startGame();

        System.out.println("----------------------");

        teamRNG.setGameStrategy(new SteadyGameStrategy());
        teamRNG.startGame();
    }
}

3.2 使用场景

四、状态模式

概念:状态模式,对有状态的对象,把负责的"判断逻辑"提取到不同的状态对象中,允许状态对象在其内部状态发生改变的时候改变其行为;

抽象状态类

package com.vleus.design.behavioral.state;

public interface TeamState {

    //玩游戏的状态
    void playGame();

    //切换到下一个状态
    TeamState next();
}

状态实现类1

package com.vleus.design.behavioral.state;

/**
 * @author vleus
 * @date 2021年06月06日 16:19
 */
public class VocationState implements TeamState{

    @Override
    public void playGame() {
        System.out.println("在三亚度假,真舒服,不想打游戏。。。");
    }

    //切换到下一个状态
    @Override
    public TeamState next() {
        return new EatBeefNoodlesState();
    }
}

状态实现类2

package com.vleus.design.behavioral.state;

/**
 * @author vleus
 * @date 2021年06月06日 16:20
 */
public class EatBeefNoodlesState implements TeamState{

    @Override
    public void playGame() {
        System.out.println("恰牛肉面恰饱饱。。。。");
    }

    @Override
    public TeamState next() {
        return new MatchState();
    }
}

状态实现类3

package com.vleus.design.behavioral.state;

/**
 * @author vleus
 * @date 2021年06月06日 16:18
 */
public class MatchState implements TeamState{

    @Override
    public void playGame() {
        System.out.println("全力以赴打比赛...");
    }

    @Override
    public TeamState next() {
        return new VocationState();
    }
}

环境类调用

package com.vleus.design.behavioral.state;

/**
 * @author vleus
 * @date 2021年06月06日 16:17
 * @desc 环境类
 */
public class SktTeam {

    private TeamState teamState;

    public void setTeamState(TeamState teamState) {
        this.teamState = teamState;
    }

    void startGame() {
        //状态不同可能会导致不同的游戏结果
        teamState.playGame();
    }

    //下一个状态
    void nextState() {
        teamState = teamState.next();
    }
}

测试类

package com.vleus.design.behavioral.state;

/**
 * @author vleus
 * @date 2021年06月06日 16:20
 */
public class MainTest {

    public static void main(String[] args) {

        SktTeam sktTeam = new SktTeam();
        VocationState state = new VocationState();
        sktTeam.setTeamState(state);

        sktTeam.startGame();
        sktTeam.nextState();
        sktTeam.startGame();
        sktTeam.nextState();
        sktTeam.startGame();
    }
}

五、中介者模式

网状变星状

在这里插入图片描述

概念:用一个中介对象来封装一系列的对象交互,中介者使得各个对象之间不需要显式地互相调用,减少对象间混乱的依赖关系,从而使其耦合松散,而且可以独立地改变他们之间的交互。属于对象行为模式。

六、观察者模式

概念:定义对象间的一种一对多依赖关系,使得当一个对象状态发生改变时,其相关依赖对象皆得到通知并被自动更新。观察者模式又被成为发布-订阅模式。
核心:被观察对象维护观察对象的引用集合,发生变化的时候通知每一个观察对象即可,就拿tiktok的关注主播为例

抽象主播类:

package com.vleus.design.behavioral.observer;

/**
 * @author vleus
 * @date 2021年06月06日 17:50
 */
public abstract class AbstractTikToker {

    //添加粉丝
    abstract void addFans(AbstractFans abstractFans);

    //通知粉丝
    abstract void notifyFans(String msg);
}

美女主播实现类

package com.vleus.design.behavioral.observer;

import com.vleus.design.structural.flyweight.AbstractWaitressFlyweight;

import java.util.ArrayList;
import java.util.List;

/**
 * @author vleus
 * @date 2021年06月06日 17:52
 */
public class MMTikToker extends AbstractTikToker {

    List<AbstractFans> fansList = new ArrayList<>();

    void startSell() {
        System.out.println("主播开始卖货了。。。");
        notifyFans("我开始卖货了,卖茅台。。。");
    }

    void enbSell() {

        System.out.println("主播货卖完了。。。");
        notifyFans("茅台已经卖完了");
    }

    @Override
    void addFans(AbstractFans abstractFans) {
        fansList.add(abstractFans);
    }

    /**
     * 通知粉丝
     */
    @Override
    void notifyFans(String msg) {
        //遍历粉丝
        for (AbstractFans abstractFans : fansList) {
            abstractFans.acceptMsg(msg);
        }
    }
}

抽象粉丝类

package com.vleus.design.behavioral.observer;

/**
 * @author vleus
 * @date 2021年06月06日 17:52
 */
public abstract class AbstractFans {

    abstract void acceptMsg(String msg);

    void follow(AbstractTikToker tikToker) {
        //主播增加粉丝
        tikToker.addFans(this);
    }
}

粉丝实现类

package com.vleus.design.behavioral.observer;

/**
 * @author vleus
 * @date 2021年06月06日 17:57
 */
public class HumanFans extends AbstractFans{

    @Override
    void acceptMsg(String msg) {
        System.out.println("粉丝说主播说:" +msg);
    }
}

测试类

package com.vleus.design.behavioral.observer;

/**
 * @author vleus
 * @date 2021年06月06日 17:56
 */
public class MainTest {

    public static void main(String[] args) {

        MMTikToker mmTikToker = new MMTikToker();

        mmTikToker.startSell();

        HumanFans humanFans1 = new HumanFans();
        HumanFans humanFans2 = new HumanFans();
        HumanFans humanFans3 = new HumanFans();

        humanFans1.follow(mmTikToker);
        humanFans2.follow(mmTikToker);
        humanFans3.follow(mmTikToker);

        System.out.println("---------------------------");

        mmTikToker.enbSell();
    }
}

6.1 使用场景

加载全部内容

相关教程
猜你喜欢
用户评论