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 模板方法使用场景

• spring的整个继承体系都基本用到模板方法：
• beanfactory：getbean-a-b-c-d；
• jdbctemplate、redistemplate都允许再扩展

三、策略模式

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

• 抽象策略类（strategy）；
• 具体策略（concrete 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 使用场景

• spring的instantiationstrategy；
• 线程池拒绝策略；
  

四、状态模式

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

• 环境类角色；
• 抽象状态角色；
• 具体状态角色

抽象状态类

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 使用场景

• spring事件通知机制；
• 响应式编程；
• vue的双向绑定核心

到此这篇关于java设计模式之初识行为型模式的文章就介绍到这了,更多相关java行为型模式内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！