行为型模式

最新推荐文章于 2025-06-04 17:55:07 发布
最新推荐文章于 2025-06-04 17:55:07 发布
阅读量103 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_63104855/article/details/124393306
版权

目录

1、模板方法模式（Template）

2、命令模式（Command）

3、备忘录模式（Memento）

4、状态模式（State）

5、职责链模式（Chain of Responsibility）

6、观察者模式（Observer）

7、策略模式（Strategy）

1、模板方法模式（Template）

  • 钩子函数 在模板方法模式的父类中，我们可以定义一个方法，它默认不做任何事，子类可以视情况要不要覆盖它，该方法称为“钩子”

  • 算法只存在于一个地方，也就是在父类中，容易修改。需要修改算法时，只要修改父类的模板方法或者已经实现的某些步骤，子类就会继承这些修改

  • 一般模板方法都加上 final 关键字， 防止子类重写模板方法

案例：

使用前

public class CodeTotalTime {

    public static void template(){
        long start = System.currentTimeMillis();
        //        检测Operation_1方法运行的时长======33
        Operation_1();
        //        检测Operation_2方法运行的时长======616
        //        Operation_2();
        long end = System.currentTimeMillis();
        System.out.println(end-start);
    }

    public static void Operation_1(){

        for (int i = 0; i<1000 ;i++){
            System.out.println("模拟耗时操作...");
        }
        System.out.print("检测Operation_1方法运行的时长======");
    }

    public static void Operation_2(){

        for (int i = 0; i<20000 ;i++){
            System.out.println("模拟耗时操作...");
        }

        System.out.print("检测Operation_2方法运行的时长======");
    }

}


public class Client {
    public static void main(String[] args) {
        CodeTotalTime.template();
    }
}

使用后

abstract class CodeAbstractClass {
	public void template() {
		long start = System.currentTimeMillis();
		method();
		long end = System.currentTimeMillis();
		System.out.println("当前方法执行时长：" + (end - start));
	}

	public abstract void method();
}

class ConcreteClassA extends CodeAbstractClass {
	@Override
	public void method() {
		for (int i = 0; i < 1000; i++) {
			System.out.println("模拟耗时操作...");
		}
		System.out.print("检测ConcreteClassA.method方法运行的时长======");
	}
}

class ConcreteClassB extends CodeAbstractClass {
	@Override
	public void method() {
		for (int i = 0; i < 20000; i++) {
			System.out.println("模拟耗时操作...");
		}
		System.out.print("ConcreteClassB.method方法运行的时长======");
	}
}


public class Client {    
	public static void main(String[] args) {
		//检测ConcreteClassA.method方法运行的时长======当前方法执行时长：
		new ConcreteClassA().template();        
		//ConcreteClassB.method方法运行的时长======当前方法执行时长：       
		new ConcreteClassB().template();    
	}
}

钩子函数应用场景

public abstract class CodeAbstractClass {
    public void template() {
        long start = System.currentTimeMillis();
        if (callback()) method();
        long end = System.currentTimeMillis();
        System.out.println("当前方法执行时长：" + (end - start));
    }

    public abstract void method();

    public boolean callback() {
        return true;
    }
}

2、命令模式（Command）

作用：

  • 将发起请求的对象与执行请求的对象解耦

  • 容易实现对请求的撤销和重做

  • 空命令也是一种设计模式，它为我们省去了判空的操作

命令模式不足： ​ 可能导致某些系统有过多的具体命令类，增加了系统的复杂度

与外观模式相似：都是将多个功能聚合在一起 ​ 外观模式更多适用于维护；命令模式更多应用于设计

术语

  • Command：命令

  • ConcreteCommand：具体的命令

  • Invoker：调用者

  • Receiver：接受者

标准URL视图 

 

案例：万能遥控器

案例UML类图

 

 使用前：

public class Light {
	public void on() {
		System.out.println("电灯打开...");
	}

	public void off() {
		System.out.println("电灯关闭...");
	}
}

class AirConditioner {
	public void on() {
		System.out.println("空调打开...");
	}

	public void off() {
		System.out.println("空调关闭...");
	}
}

class Television {
	public void on() {
		System.out.println("电视打开...");
	}

	public void off() {
		System.out.println("电视关闭...");
	}
}
public class Invoker {
    private Light light = new Light();
    private AirConditioner airConditioner = new AirConditioner();
    private Television television = new Television();

    public void lightOn() {
        light.on();
    }

    public void lightOff() {
        light.off();
    }

    public void airOn() {
        airConditioner.on();
    }

    public void airOff() {
        airConditioner.off();
    }

    public void tvOn() {
        television.on();
    }

    public void tvOff() {
        television.off();
    }
}

package com.zking.command.demo1;

public class Client {
    public static void main(String[] args) {
        Invoker invoker = new Invoker();
        invoker.lightOn();
        invoker.lightOff();
        System.out.println("=============");
        invoker.airOn();
        invoker.airOff();
        System.out.println("=============");
        invoker.tvOn();
        invoker.tvOff();
    }
}

使用后：

public class Light {
	public void on() {
		System.out.println("电灯打开...");
	}

	public void off() {
		System.out.println("电灯关闭...");
	}
}

class AirConditioner {
	public void on() {
		System.out.println("空调打开...");
	}

	public void off() {
		System.out.println("空调关闭...");
	}
}

class Television {
	public void on() {
		System.out.println("电视打开...");
	}

	public void off() {
		System.out.println("电视关闭...");
	}
}


interface Command {
	void execute();

	void undo();
}// 空命令

class NonCommand implements Command {
	@Override
	public void execute() {
	}

	@Override
	public void undo() {
	}
}

class LightOnCommand implements Command {
	private Light light = new Light();

	@Override
	public void execute() {
		light.on();
	}

	@Override
	public void undo() {
		light.off();
	}
}

class LightOffCommand implements Command {
	private Light light = new Light();

	@Override
	public void execute() {
		light.off();
	}

	@Override
	public void undo() {
		light.on();
	}
}

class TvOnCommand implements Command {
	private Television tv = new Television();

	@Override
	public void execute() {
		tv.on();
	}

	@Override
	public void undo() {
		tv.off();
	}
}

class TvOffCommand implements Command {
	private Television tv = new Television();

	@Override
	public void execute() {
		tv.off();
	}

	@Override
	public void undo() {
		tv.on();
	}
}

public class Invoker {
	Command[] ons;
	Command[] offs;// 记录上一个命令
	Command command;

	public Invoker(int n) {
		ons = new Command[n];
		offs = new Command[n];
		command = new NonCommand();
		for (int i = 0; i < n; i++) {
			setCommand(i, new NonCommand(), new NonCommand());
		}
	}

	public void setCommand(int no, Command on, Command off) {
		ons[no] = on;
		offs[no] = off;
	}

	public Command getOnCommand(int no) {
		return ons[no];
	}

	public Command getOffCommand(int no) {
		return offs[no];
	}

	// 执行命令
	public void invoke(Command command) {
		// 执行当前命令
		command.execute();// 保存当前执行命令
		this.command = command;
	}// 撤销命令（上个操作的反操作）

	public void undo() {// 这里就能体现定义一个空命令的好处了，如果第一次按撤销命令，那么应该什么都不做；// 如果没有定义空命令的话，此时就需要判断空处理了
		command.undo();
	}
}


public class Client {
	public static void main(String[] args) {
		Invoker invoker = new Invoker(2);
		invoker.setCommand(0, new LightOnCommand(), new LightOffCommand());
		invoker.setCommand(1, new TvOnCommand(), new TvOffCommand());
		System.out.println("电灯打开关闭操作===========");
		invoker.invoke(invoker.getOnCommand(0));
		invoker.invoke(invoker.getOffCommand(0));
		// invoker.undo();
		System.out.println("电视打开关闭操作===========");
		invoker.invoke(invoker.getOnCommand(1));
		invoker.undo();
	}
}

应用场景：

Spring框架中的JdbcTemplate类 容易设计一个命令队列。只要把命令对象放到列队，就可以多线程的执行命令 界面的一个按钮都是一条命令、模拟 CMD（DOS 命令）订单的撤销/恢复、触发- 反馈机制

3、备忘录模式（Memento）

术语：

Memento：备忘录

originator：发起者

Caretaker：守护者

简介：可以使用户能够比较方便地回到某个历史的状态

  • 注意事项和细节

    • 给用户提供了一种可以恢复状态的机制，可以使用户能够比较方便地回到某个历史的状态

    • 实现了信息的封装，使得用户不需要关心状态的保存细节

注意：如果类的成员变量过多，势必会占用比较大的资源，而且每一次保存都会消耗一定的内存

UML类图：

案例：游戏人物大战后状态恢复

 情况1：为一个对象保留一个状态 

public class Hero {
    //    需要存档的属性：这里用一个state属性来表示，实际需要存档的属性可能会有很多
    private String state;

    public Hero(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }    //    将当前Hero对象实例进行备份

    public HeroMemento saveHero() {
        return new HeroMemento(this.state);
    }

    //    恢复上一个英雄状态
    public void getMemento(HeroMemento heroMemento) {
        this.state = heroMemento.getState();
    }
}


package com.zking.memento.demo1;

public class Caretaker {
    private HeroMemento heroMemento;

    public HeroMemento getHeroMemento() {
        return heroMemento;
    }

    public void setHeroMemento(HeroMemento heroMemento) {
        this.heroMemento = heroMemento;
    }
}

package com.zking.memento.demo1;

public class HeroMemento {
    private String state;

    public HeroMemento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
}

package com.zking.memento.demo1;

public class Client {
    public static void main(String[] args) {
        Hero hero = new Hero("状态1，满血状态");
        Caretaker caretaker = new Caretaker();
        caretaker.setHeroMemento(hero.saveHero());
        hero.setState("状态2：状态下滑");
        System.out.println("当前的状态===============" + hero.getState());
        hero.getMemento(caretaker.getHeroMemento());
        System.out.println("当前的状态===============" + hero.getState());
        caretaker.setHeroMemento(hero.saveHero());
        hero.setState("状态3：残血状态");
        hero.getMemento(caretaker.getHeroMemento());
        System.out.println("当前的状态===============" + hero.getState());
        caretaker.setHeroMemento(hero.saveHero());
        hero.setState("状态4：临死状态");
        caretaker.setHeroMemento(hero.saveHero());
    }
}

情况2：为一个对象保留多个状态

public class Hero {
    //    需要存档的属性：这里用一个state属性来表示，实际需要存档的属性可能会有很多
    private String state;

    public Hero(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }    //    将当前Hero对象实例进行备份

    public HeroMemento saveHero() {
        return new HeroMemento(this.state);
    }    //    恢复某一个英雄状态

    public void getMemento(Caretaker caretaker, int no) {
        this.state = caretaker.getMemento(no).getState();
    }
}

package com.zking.memento.demo2;

public class HeroMemento {
    private String state;

    public HeroMemento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
}

package com.zking.memento.demo2;

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

public class Caretaker {
    private List<HeroMemento> heroMementos = new ArrayList<>();

    public void addMemento(HeroMemento memento) {
        heroMementos.add(memento);
    }

    public HeroMemento getMemento(int no) {
        return heroMementos.get(no);
    }
}

package com.zking.memento.demo2;

public class Client {
    public static void main(String[] args) {
        Hero hero = new Hero("状态1，满血状态");
        Caretaker caretaker = new Caretaker();
        caretaker.addMemento(hero.saveHero());
        hero.setState("状态2：状态下滑");
        hero.setState("状态3：残血状态");
        caretaker.addMemento(hero.saveHero());
        hero.setState("状态4：临死状态");
        caretaker.addMemento(hero.saveHero());
        hero.setState("状态5：死亡状态");
        //        上面备份了1、3、4状态，我来恢复看看         
        System.out.println("当前的状态===============" + hero.getState());
        hero.getMemento(caretaker, 0);
        System.out.println("回复到状态1===============" + hero.getState());
        hero.getMemento(caretaker, 1);
        System.out.println("回复到状态3===============" + hero.getState());
        hero.getMemento(caretaker, 2);
        System.out.println("回复到状态4===============" + hero.getState());
    }
}

情况3：为多个对象保留一个状态

 package com.zking.memento.demo2;

public class Hero {
    //    需要存档的属性：这里用一个state属性来表示，实际需要存档的属性可能会有很多
    private String state;

    public Hero(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }    //    将当前Hero对象实例进行备份

    public HeroMemento saveHero() {
        return new HeroMemento(this.state);
    }    //    恢复某一个英雄状态

    public void getMemento(Caretaker caretaker, int no) {
        this.state = caretaker.getMemento(no).getState();
    }
}

package com.zking.memento.demo2;

public class HeroMemento {
    private String state;

    public HeroMemento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
}

package com.zking.memento.demo2;

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

public class Caretaker {
   private HashMap<Originator ,Memento> mementos = new HashMap();

    public void addMemento(HeroMemento memento) {
        heroMementos.add(memento);
    }

    public HeroMemento getMemento(int no) {
        return heroMementos.get(no);
    }
}

package com.zking.memento.demo2;

public class Client {
    public static void main(String[] args) {
        Hero hero = new Hero("状态1，满血状态");
        Caretaker caretaker = new Caretaker();
        caretaker.addMemento(hero.saveHero());
        hero.setState("状态2：状态下滑");
        hero.setState("状态3：残血状态");
        caretaker.addMemento(hero.saveHero());
        hero.setState("状态4：临死状态");
        caretaker.addMemento(hero.saveHero());
        hero.setState("状态5：死亡状态");
        //        上面备份了1、3、4状态，我来恢复看看         
        System.out.println("当前的状态===============" + hero.getState());
        hero.getMemento(caretaker, 0);
        System.out.println("回复到状态1===============" + hero.getState());
        hero.getMemento(caretaker, 1);
        System.out.println("回复到状态3===============" + hero.getState());
        hero.getMemento(caretaker, 2);
        System.out.println("回复到状态4===============" + hero.getState());
    }
}

 情况4：为多个对象保留多个对象

public class Hero {
    //    需要存档的属性：这里用一个state属性来表示，实际需要存档的属性可能会有很多
    private String state;

    public Hero(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }    //    将当前Hero对象实例进行备份

    public HeroMemento saveHero() {
        return new HeroMemento(this.state);
    }    //    恢复某一个英雄状态

    public void getMemento(Caretaker caretaker, int no) {
        this.state = caretaker.getMemento(no).getState();
    }
}

package com.zking.memento.demo2;

public class HeroMemento {
    private String state;

    public HeroMemento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
}

package com.zking.memento.demo2;

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

public class Caretaker {
    private HashMap<Originator , List<Memento>> mementos  = new HashMap();

    public void addMemento(HeroMemento memento) {
        heroMementos.add(memento);
    }

    public HeroMemento getMemento(int no) {
        return heroMementos.get(no);
    }
}

package com.zking.memento.demo2;

public class Client {
    public static void main(String[] args) {
        Hero hero = new Hero("状态1，满血状态");
        Caretaker caretaker = new Caretaker();
        caretaker.addMemento(hero.saveHero());
        hero.setState("状态2：状态下滑");
        hero.setState("状态3：残血状态");
        caretaker.addMemento(hero.saveHero());
        hero.setState("状态4：临死状态");
        caretaker.addMemento(hero.saveHero());
        hero.setState("状态5：死亡状态");
        //        上面备份了1、3、4状态，我来恢复看看         
        System.out.println("当前的状态===============" + hero.getState());
        hero.getMemento(caretaker, 0);
        System.out.println("回复到状态1===============" + hero.getState());
        hero.getMemento(caretaker, 1);
        System.out.println("回复到状态3===============" + hero.getState());
        hero.getMemento(caretaker, 2);
        System.out.println("回复到状态4===============" + hero.getState());
    }
}

应用场景：

事务回滚

游戏的存档

Selenium动态解析资源树

4、状态模式（State）

  • 代码有很强的可读性。状态模式将每个状态的行为封装到对应的一个类中方便维护

UML类图

 

 案例：抽奖活动项目设计

使用前：

 

public class State {
    //    当前的状态
    private int state;
    //    供抽奖的积分
    private int score;
    //    奖品的数量
    private int count;

    public State(int score, int count) {
        this.score = score;
        this.count = count;
    }

    public int getCount() {
        return count;
    }

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    //    扣除积分
    public void minus() {
//        只有一阶段可以扣积分
        this.state = 1;
        if (this.state == 1) {
            if (this.score >= 50) {
                if (this.count == 0) {
                    System.out.println("奖品领完....");
                    return;
                }
                this.score = this.score - 50;
                System.out.println("========扣除50积分，当前积分还剩" + this.score + "========");
                this.state = 2;
                if (luckHit()) {
                    this.state = 3;
                    getPrize();
                }
            } else {
                System.out.println("========积分不够，当前积分为" + this.score + "========");
            }
        }

    }

    //    十分之一抽中奖品的概率
    public boolean luckHit() {
//        只有二阶段可以抽奖
        return this.state == 2 ? (new Random().nextInt(10) == 6) : false;
    }

    public void getPrize() {
        if (this.state == 3) {
            if (this.count > 0) {
                System.out.println("领取奖品....");
                this.count = this.count - 1;
            } else {
                System.out.println("奖品领完....");
            }
        }
    }

}


public class Client {
    public static void main(String[] args) {
        State state = new State(500,1);
//        state.minus();
        for (int i = 0; i < 300; i++) {
            state.minus();
        }
    }
}

从上面的编码中，我们可以看出，完成该需求有很多的条件判断，非常不利于后续的维护；上面状态只有4个，代码已经比较复杂了；状态越多，代码嵌套就越复杂，维护成本就越高；

使用后：

public abstract class State {

//    扣积分
    abstract void minus();
//    抽奖
    abstract boolean luckHit();
//    获取奖品
    abstract void getPrize();

}

class ConcreteStateA extends State{
    Context context;

    public ConcreteStateA(Context context) {
        this.context = context;
    }

    @Override
    void minus() {
        if(context.getScore()>=50){
            context.setScore(context.getScore()-50);
            System.out.println("========扣除50积分，当前积分还剩"+context.getScore()+"========");
            context.setState(context.getStateB());
        }else{
            System.out.println("========积分不够，当前积分为"+context.getScore()+"========");
        }
    }

    @Override
    boolean luckHit() {
        System.out.println("还在扣费环节，不能抽奖...");
        return false;
    }

    @Override
    void getPrize() {
        System.out.println("还在扣费环节，不能领取奖品...");
    }
}

class ConcreteStateB extends State{
    Context context;

    public ConcreteStateB(Context context) {
        this.context = context;
    }

    @Override
    void minus() {
        System.out.println("已经在抽奖环节...");
    }

    @Override
    boolean luckHit() {
        boolean flag = new Random().nextInt(10) == 6;
        if(flag){
            context.setState(context.getStateC());
        }else{
            context.setState(context.getStateA());
        }
        return flag;
    }

    @Override
    void getPrize() {
        System.out.println("还在抽奖环节，不能领取奖品...");
    }
}

class ConcreteStateC extends State{
    Context context;

    public ConcreteStateC(Context context) {
        this.context = context;
    }

    @Override
    void minus() {
        System.out.println("已经在领取奖品环节...");
    }

    @Override
    boolean luckHit() {
        System.out.println("已经在领取奖品环节...");
        return false;
    }

    @Override
    void getPrize() {
        if(context.getCount()>0){
            System.out.println("领取奖品成功...");
            context.setState(context.getStateA());
        }else {
            System.out.println("活动结束，领取奖品失败...");
            context.setState(context.getStateD());
//            不继续抽奖
//            System.exit(0);
        }
    }
}

class ConcreteStateD extends State{
    Context context;

    public ConcreteStateD(Context context) {
        this.context = context;
    }

    @Override
    void minus() {
        System.out.println("已经在活动结束，奖品送完环节...");
    }

    @Override
    boolean luckHit() {
        System.out.println("已经在活动结束，奖品送完环节...");
        return false;
    }

    @Override
    void getPrize() {
        System.out.println("已经在活动结束，奖品送完环节...");
    }
}


public class Context {
    //    当前的状态
    private State state;
    //    奖品数量
    public int count;
    //    用户积分
    private int score;

    //    表示同一个对象的四种状态
    private ConcreteStateA stateA = new ConcreteStateA(this);
    private ConcreteStateB stateB = new ConcreteStateB(this);
    private ConcreteStateC stateC = new ConcreteStateC(this);
    private ConcreteStateD stateD = new ConcreteStateD(this);


    public Context(int score, int count) {
        this.score = score;
        this.count = count;
        this.state = stateA;
    }

    //    扣积分
    public void minus() {
        state.minus();
    }

    //    抽奖
    public void luckHit() {
        if (state.luckHit()) {
            state.getPrize();
        }
    }

    public State getState() {
        return state;
    }

    public void setState(State state) {
        this.state = state;
    }

    public int getCount() {
        return count--;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public ConcreteStateA getStateA() {
        return stateA;
    }

    public void setStateA(ConcreteStateA stateA) {
        this.stateA = stateA;
    }

    public ConcreteStateB getStateB() {
        return stateB;
    }

    public void setStateB(ConcreteStateB stateB) {
        this.stateB = stateB;
    }

    public ConcreteStateC getStateC() {
        return stateC;
    }

    public void setStateC(ConcreteStateC stateC) {
        this.stateC = stateC;
    }

    public ConcreteStateD getStateD() {
        return stateD;
    }

    public void setStateD(ConcreteStateD stateD) {
        this.stateD = stateD;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }
}


public class Client {
    public static void main(String[] args) {
//        这次游戏积分500个，用完为止，总奖品数2
        Context context = new Context(500,1);
//        context.lunkHit();//还在扣费环节，不能抽奖...

        for (int i = 0; i < 300; i++) {
            context.minus();
            context.luckHit();
        }
        System.out.println("------------------");

    }
}

 运行代码视图：

 

 

 缺点：会产生很多类。每个状态都要一个对应的类，当状态过多时会产生很多类，加大维护难度

 应用场景：

        当一个事件或者对象有很多种状态，状态之间会相互转换，对不同的状态要求有不同的行为的时候， 可以考虑使用状态模式

        借贷平台状态管理

5、职责链模式（Chain of Responsibility）

职责链模式：将请求和处理分开，实现解耦，提高系统的灵活性 简化了对象，使对象不需要知道链的结构

 注意：性能会受到影响，特别是在链比较长的时候，因此需控制链中最大节点数量，一般通过在 Handler 中设置一个最大节点数量，在 setNext()方法中判断是否已经超过阀值，超过则不允许该链建立，避免出现超长链无意识地破坏系统性能

案例：

OA系统请假审批案例（

学生请假1天：教员审批

学生请假2天：教学主管审批

学生请假3天：教学经理审批

学生请假5天：副校长审批

学生请假超过5天：校长审批

）

使用前：

public class Request {
    private String content;
    private int day;

    public Request(String content, int day) {
        this.content = content;
        this.day = day;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }
}


package com.javaxl.design.chain.before;

/**
 * @author 小李飞刀
 * @site www.javaxl.com
 * @company
 * @create  2020-02-25 19:31
 */
public class Handler {

    public void handle(Request request){
        int day = request.getDay();
        if(day <= 1){
            System.out.println("教员处理了:因 " + request.getContent() + " 请假" + day + "天的请求");
        }else if(day <= 2){
            System.out.println("教学主管处理了:因 " + request.getContent() + " 请假" + day + "天的请求");
        }else if(day <= 3){
            System.out.println("教学经理处理了:因 " + request.getContent() + " 请假" + day + "天的请求");
        }else if(day <= 5){
            System.out.println("副校长处理了:因 " + request.getContent() + " 请假" + day + "天的请求");
        }else {
            System.out.println("校长处理了:因 " + request.getContent() + " 请假" + day + "天的请求");
        }
    }
}


public class Client {
    public static void main(String[] args) {
        Handler handler = new Handler();
        Request request1 = new Request("小感冒",1);
        handler.handle(request1);

        Request request2 = new Request("做检查",2);
        handler.handle(request2);

        Request request3 = new Request("打点滴",3);
        handler.handle(request3);


        Request request4 = new Request("住院",4);
        handler.handle(request4);

        Request request5 = new Request("在家调养",30);
        handler.handle(request5);
    }
}

违背了迪米特法则，调用方清楚的知道整个处理链的存在；

使用后：

public class Request {
    private String content;
    private int day;

    public Request(String content, int day) {
        this.content = content;
        this.day = day;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }
}

public abstract class Handler {
    Handler next;
    String name;

    public Handler(String name) {
        this.name = name;
    }

    public Handler getNext() {
        return next;
    }

    public void setNext(Handler next) {
        this.next = next;
    }

    public abstract void handle(Request request);
}

class HandlerA extends Handler {
    public HandlerA(String name) {
        super(name);
    }

    public void handle(Request request) {
        int day = request.getDay();
        if (day <= 1) {
            System.out.println(this.name + "处理了:因 " + request.getContent() + " 请假" + day + "天的请求");
        } else {
            next.handle(request);
        }
    }
}

class HandlerB extends Handler {
    public HandlerB(String name) {
        super(name);
    }

    public void handle(Request request) {
        int day = request.getDay();
        if (day <= 2) {
            System.out.println(this.name + "处理了:因 " + request.getContent() + " 请假" + day + "天的请求");
        } else {
            next.handle(request);
        }
    }
}

class HandlerC extends Handler {
    public HandlerC(String name) {
        super(name);
    }

    public void handle(Request request) {
        int day = request.getDay();
        if (day <= 3) {
            System.out.println(this.name + "处理了:因 " + request.getContent() + " 请假" + day + "天的请求");
        } else {
            next.handle(request);
        }
    }
}

class HandlerD extends Handler {
    public HandlerD(String name) {
        super(name);
    }

    public void handle(Request request) {
        int day = request.getDay();
        if (day <= 5) {
            System.out.println(this.name + "处理了:因 " + request.getContent() + " 请假" + day + "天的请求");
        } else {
            next.handle(request);
        }
    }
}

class HandlerE extends Handler {
    public HandlerE(String name) {
        super(name);
    }

    public void handle(Request request) {
        int day = request.getDay();
        System.out.println(this.name + "处理了:因 " + request.getContent() + " 请假" + day + "天的请求");
    }
}


public class Client {
    public static void main(String[] args) {
        HandlerA handlerA = new HandlerA("教员");
        HandlerB handlerB = new HandlerB("教学主管");
        HandlerC handlerC = new HandlerC("教学经理");
        HandlerD handlerD = new HandlerD("副校长");
        HandlerE handlerE = new HandlerE("校长");
        handlerA.setNext(handlerB);
        handlerB.setNext(handlerC);
        handlerC.setNext(handlerD);
        handlerD.setNext(handlerE);

        Request request1 = new Request("小感冒",1);
        handlerA.handle(request1);

        Request request2 = new Request("做检查",2);
        handlerA.handle(request2);

        Request request3 = new Request("打点滴",3);
        handlerA.handle(request3);


        Request request4 = new Request("住院",4);
        handlerA.handle(request4);

        Request request5 = new Request("在家调养",30);
        handlerA.handle(request5);
    }
}

应用场景：springmvc框架~HandlerExcutionChain类 工作流框架绘图生成xml反射实例化，整个流程归档过程 js中的原型链

6、观察者模式（Observer）

集合的方式来管理用户(Observer)，包括注册，移除和通知

UML类图

案例：气象站数据更新推送问题

 使用前：

public class WeatherData {
    double temperature;
    double humidity;

    public WeatherData(double temperature, double humidity) {
        this.temperature = temperature;
        this.humidity = humidity;
    }

    public void getWeatherInfo() {
        System.out.println("当前温度：" + temperature + ",当前湿度：" + humidity);
    }

    public void change(double temperature, double humidity) {
        this.temperature = temperature;
        this.humidity = humidity;
    }
}



public class Baidu {
    private WeatherData weatherData;

    public Baidu(WeatherData weatherData) {
        this.weatherData = weatherData;
    }

    public void getWeatherInfo() {
        System.out.print("百度网站温馨提示===>");
        weatherData.getWeatherInfo();
    }
}

class Sina {
    private WeatherData weatherData;

    public Sina(WeatherData weatherData) {
        this.weatherData = weatherData;
    }

    public void getWeatherInfo() {
        System.out.print("新浪网站温馨提示===>");
        weatherData.getWeatherInfo();
    }
}


public class Client {
    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData(30,20);
        Baidu baidu = new Baidu(weatherData);
        Sina sina = new Sina(weatherData);
        baidu.getWeatherInfo();
        sina.getWeatherInfo();
        weatherData.change(10,10);
        baidu.getWeatherInfo();
        sina.getWeatherInfo();
    }
}

 由第三方（百度、新浪）主动获取最新天气信息，这种方案需要每个第三方主动定时获取最新天气数据，涉及多个第三方；

 使用后：

public interface Subject {
    void addObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

class WeatherData implements Subject{
    double temperature;
    double humidity;
    List<Observer> Observers = new ArrayList<>();

    public WeatherData(double temperature, double humidity) {
        this.temperature = temperature;
        this.humidity = humidity;
    }

    public void update(double temperature, double humidity) {
        this.temperature = temperature;
        this.humidity = humidity;
//        气象局数据一改变，马上通知接入的第三方/观察者
        notifyObservers();
    }

    @Override
    public void addObserver(Observer observer) {
        Observers.add(observer);
        observer.update(this.temperature,this.humidity);
    }

    @Override
    public void removeObserver(Observer observer) {
        Observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : Observers) {
            observer.update(this.temperature,this.humidity);
        }
    }
}


public interface Observer {
    void display();
    void update(double temperature, double humidity);
}

class Baidu implements Observer{
    double temperature;
    double humidity;

    @Override
    public void display() {
        System.out.println("百度温馨提示：当前温度：" + temperature + ",当前湿度：" + humidity);
    }

    @Override
    public void update(double temperature, double humidity) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.display();
    }
}

class Sina implements Observer{
    double temperature;
    double humidity;

    @Override
    public void display() {
        System.out.println("新浪温馨提示：当前温度：" + temperature + ",当前湿度：" + humidity);
    }

    @Override
    public void update(double temperature, double humidity) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.display();
    }
}

public class Client {
    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData(30, 20);
        Baidu baidu = new Baidu();
        Sina sina = new Sina();
        weatherData.addObserver(baidu);
        weatherData.addObserver(sina);
        weatherData.update(10, 10);
        weatherData.removeObserver(baidu);
        weatherData.update(12, 12);
    }
}

由气象局主动通知第三方，天气数据发生了改变；并且，第三方的接入可以控制（增加、删除、通知）；

应用场景：JDK源码中Observable类

7、策略模式（Strategy）

分析项目中变化部分与不变部分体现了“对修改关闭，对扩展开放”原则，客户端增加行为不用修改原有代码，只要添加一种策略（或者行为） 即可策略模式将算法封装在独立的 Strategy 类中使得你可以独立于其 Context 改变它，使它易于切换、易于理解、易于扩展

  注意：在很多场景中，策略接口会作为内部接口体现

 UML类图

 案例：学院共有专业需求

使用前：

public class Major {
    private String name;

    public Major(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {
        Major major = (Major) obj;
        return this.name.equals(major.name);
    }
}


public class College {
    String name;

    public College(String name) {
        this.name = name;
    }
}

class CollegeA extends College{
    List<Major> list = new ArrayList<>();
    CollegeA(String name){
        super(name);
        this.list.add(new Major("JAVA"));
        this.list.add(new Major("PHP"));
        this.list.add(new Major("JavaScript"));
        this.list.add(new Major("C语言"));
        this.list.add(new Major("android"));
    }
}

class CollegeB extends College{
    List<Major> list = new ArrayList<>();
    CollegeB(String name){
        super(name);
        this.list.add(new Major("iOS"));
        this.list.add(new Major("PHP"));
        this.list.add(new Major("JavaScript"));
        this.list.add(new Major("C语言"));
        this.list.add(new Major("嵌入式"));
    }
}


public class StrategyA {
    public List<Major> intersect(List<Major> a,List<Major> b){
        List<Major> list = new ArrayList();
        for (Major major : a) {
            if(b.contains(major)){
                list.add(major);
            }
        }
        return list;
    }
}

class StrategyB {
    public List<Major> intersect(List<Major> a,List<Major> b){
//        a.retainAll(b);
        b.retainAll(a);
        return b;
    }
}

public class Client {
    public static void main(String[] args) {
        StrategyA strategyA = new StrategyA();
        CollegeA a = new CollegeA("华东交通大学");
        CollegeB b = new CollegeB("东华理工大学");
        List<Major> intersect = strategyA.intersect(a.list, b.list);
        System.out.println(a.name + "与" + b.name + "都有的专业");
        for (Major major : intersect) {
            System.out.println(major.getName());
        }

        StrategyB strategyB = new StrategyB();
        List<Major> intersect2 = strategyB.intersect(a.list, b.list);
        System.out.println(a.name + "与" + b.name + "都有的专业");
        for (Major major : intersect2) {
            System.out.println(major.getName());
        }
    }
}

使用后:

public class Major {
    private String name;

    public Major(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {
        Major major = (Major) obj;
        return this.name.equals(major.name);
    }
}


public class College {
    String name;

    public College(String name) {
        this.name = name;
    }
}

class CollegeA extends College {
    List<Major> list = new ArrayList<>();
    CollegeA(String name){
        super(name);
        this.list.add(new Major("JAVA"));
        this.list.add(new Major("PHP"));
        this.list.add(new Major("JavaScript"));
        this.list.add(new Major("C语言"));
        this.list.add(new Major("android"));
    }
}

class CollegeB extends College {
    List<Major> list = new ArrayList<>();
    CollegeB(String name){
        super(name);
        this.list.add(new Major("iOS"));
        this.list.add(new Major("PHP"));
        this.list.add(new Major("JavaScript"));
        this.list.add(new Major("C语言"));
        this.list.add(new Major("嵌入式"));
    }
}

public interface Strategy {
    List<Major> intersect(List<Major> a, List<Major> b);
}

public class StrategyA implements Strategy{
    public List<Major> intersect(List<Major> a,List<Major> b){
        List<Major> list = new ArrayList();
        for (Major major : a) {
            if(b.contains(major)){
                list.add(major);
            }
        }
        return list;
    }
}

public class Context {
    public List<Major> intersect(List<Major> a, List<Major> b,Strategy strategy){
        return strategy.intersect(a,b);
    }
}

public class Client {
    public static void main(String[] args) {
        CollegeA a = new CollegeA("华东交通大学");
        CollegeB b = new CollegeB("东华理工大学");
        Context context = new Context();

        List<Major> intersect = context.intersect(a.list, b.list, new StrategyA());
        System.out.println(a.name + "与" + b.name + "都有的专业");
        for (Major major : intersect) {
            System.out.println(major.getName());
        }

//        可以随意定制策略
        List<Major> intersect2 = context.intersect(a.list, b.list, new Strategy() {
            @Override
            public List<Major> intersect(List<Major> a, List<Major> b) {
                a.retainAll(b);
                return a;
            }
        });
        System.out.println(a.name + "与" + b.name + "都有的专业========");
        for (Major major : intersect2) {
            System.out.println(major.getName());
        }
    }
}

应用场景：Arrays工具类的排序方法Comparator策略接口的使用、JDBC对Result结果集的处理

设计模式之11个行为型模式
02-24
行为型模式(BehavioralPattern)是对在不同的对象之间划分责任和算法的抽象化。行为型模式不仅仅关注类和对象的结构，而且重点关注它们之间的相互作用。在系统运行时，对象并不是孤立的，它们可以通过相互通信与协作...
23种设计模式,创建型模式共5种,结构型模式7种,行为型模式11种
12-22
设计模式分为三大类：创建型模式、结构型模式和行为型模式。 **创建型模式**关注的是对象的创建。共有五种创建型模式： 1. **工厂方法模式**：它定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法...
行为型模式简介
hopegrace的博客
01-08 3567
行为型模式简介 行为型类模式使用继承描述算法和控制流，而行为型对象模式则描述一组对象怎样协作完成单个对象无法完成的任务。 一、职责链，CHAINOFRESPONSIBILITY，对象行为型模式 使多个对象都有机会处理请求，从而避免请求的发送者和接收着之间的耦合关系。将这些对象生成一条链，并沿着这条链传递该消息，直到有一个对象处理它为止。 适用性 有多个对...
设计模式可以分为三大类：创建型模式，结构型模式，行为型模式
BLOG域名:programb.blog.youkuaiyun.com
10-04 1057
在实际项目中，设计模式可以帮助提高代码的可维护性、可扩展性和复用性。通过合理选择和应用设计模式，可以简化复杂系统的设计和实现过程。设计模式在实际项目中应用非常广泛，它们提供了一套经过验证的解决方案，用于解决常见的软件设计问题。：这些模式主要处理对象的创建过程，使得创建对象的过程更加灵活和可扩展。：这些模式主要处理类或对象的组合，以实现更复杂的结构。：这些模式主要处理对象之间的交互和通信。设计模式可以分为三大类：创建型模式，结构型模式，行为型模式。
设计模式——行为型模式
会奔跑的茄子的博客
12-26 1835
当实现某一个功能存在多种算法或者策略，我们可以根据环境或者条件的不同选择不同的算法或者策略来完成该功能策略（Strategy）模式的定义：该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。策略模式仅仅封装算法（包括添加 & 删除），但策略模式并不决定在何时使用何种算法，算法的选择由客户端来决定。
设计模式06——行为型模式
如不來的博客
03-12 2396
一、概述  行为型模式用于描述程序在运行时复杂的流程控制，即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，它涉及算法与对象间职责的分配。行为型模式分为类行为模式和对象行为模式，前者采用继承机制来在类间分派行为，后者采用组合或聚合在对象间分配行为。由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象行为模式比类行为模式具有更大的灵活性。  行为型模式包含以下 11 种模式：   1、模板方法（Template Method）模式：定义一个操作中的算法骨架，将算法的一
设计模式之行为型模式
欢迎订阅 -- 小源笔迹
10-06 984
为了减少对象两两之间复杂的引用关系，使之成为一个松耦合的系统，我们引入中介者模式，用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。状态模式的关键是引入了一个抽象类来专门表示对象的状态，对象的每一种具体状态类都继承了该类，不同的具体状态类实现了不同状态的行为。状态与行为一一对应。具体状态类是抽象状态类的子类，每一个子类实现一个与环境类的一个状态相关的行为，每一个具体状态类对应环境的一个具体状态，不同的具体状态类其行为有所不同。
C++设计模式---行为型模式
qq_51647149的博客
05-20 1030
行为型模式中模板方法模式、策略模式、命令模式、观察者模式的实现
java设计模式--行为型模式
weston666的博客
05-13 874
行为型模式关注对象交互、通信和控制流。
【设计模式】三大类：创建型模式、结构型模式、行为型模式
郭老二
07-01 5333
1 创建型模式 本人理解：以C++为例，创建对象时，用关键字new来创建（实例化）对象。用一个函数或类将new的过程封装起来，就是创建型模式。 《设计模式》中的描述： 创建型模式抽象了实例化过程。它们帮助一个系统独立于如何创建、组合和表示它的那些对象。 一个类----创建型模式使用继承改变被实例化的类， 一个对象-创建型模式将实例化委托给另一个对象。 （看后，一头雾水） 工厂模式（Factory Pattern） 抽象工厂模式（Abstract Factory Pattern） 单例模式（Singleton
行为型设计模式
shaofei_huai的博客
06-04 3736
行为型设计模式目的是将多个类或对象相互协作，共同完成单个类或对象无法单独完成的任务。行为型设计模式共11种，分别为解释器模式、模板方法模式、责任链模式、命令模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、访问者模式。 ......
12.4.4 设计模式(行为型模式).avi
01-28
12.4.4 设计模式(行为型模式)12.4.4 设计模式(行为型模式)12.4.4 设计模式(行为型模式)12.4.4 设计模式(行为型模式)12.4.4 设计模式(行为型模式)12.4.4 设计模式(行为型模式)12.4.4 设计模式(行为型模式)12.4.4 设计...
软件工程设计模式分类详解：创建型、结构型与行为型模式的概念及应用场景综述了文档的主要内容
05-20
文章将设计模式分为三大类：创建型模式、结构型模式和行为型模式。创建型模式关注对象的创建方式，包括单例模式、工厂方法模式、抽象工厂模式、建造者模式和原型模式。结构型模式关注类和对象的组合，如适配器模式、...
C#设计模式之行为型模式详解
08-29
行为型模式是设计模式的一种类型，主要关注对象之间的责任分配和交互。在这个主题中，我们将深入探讨两种行为型模式：责任链模式和命令模式。 首先，我们来看责任链模式。责任链模式是一种结构型设计模式，它的主要...
设计模式杂谈-模板设计模式
最新发布
huangyujun9920123的博客
06-04 407
用项目实战带你为你揭开设计模式神秘面纱，设计模式不再是躺在书本里晦涩难懂的概念。
【设计模式-3.4】结构型——代理模式
小何的博客
06-01 1191
【设计模式-3.4】结构型——代理模式
设计模式——抽象工厂设计模式（创建型）
庄小焱
05-31 942
抽象工厂设计模式是一种创建型设计模式，旨在提供一个接口，用于创建一系列相关或依赖的对象，无需指定具体类。它通过抽象工厂、具体工厂、抽象产品和具体产品等组件构建，相比工厂方法模式，能创建一个产品族。该模式适用于多个产品需一起创建的场景，可隐藏产品细节，便于客户端使用。
【设计模式】责任链模式
u011144881的博客
05-30 773
责任链模式是一种行为设计模式，通过构建处理者链实现请求的传递和处理。主要包含抽象处理者、具体处理者和客户端三个角色。该模式降低系统耦合度，增强扩展性，避免复杂条件语句，适用于多级审批、日志处理等场景。缺点是可能影响性能，调试较困难。代码示例展示了如何构建处理链（HandlerA->HandlerB->HandlerC）并传递不同类型的请求，每个处理者仅处理特定类型的请求。该模式提高了代码灵活性和可维护性。
C#行为型模式详解：责任链与Task应用
"C#设计模式之行为型模式详解是一篇关于C#编程中行为型模式的详细介绍文章，主要关注于行为模式在C#中的应用。行为型模式主要包括控制类的行为，如策略模式、命令模式、观察者模式、职责链模式、迭代器模式等。本文...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值