观察者模式

简介

优缺点

结构

实现

运用场景

访问者模式

简介

优缺点

结构

实现

运用场景

模板方法模式

简介

优缺点

结构

实现

运用场景

观察者模式

简介

又叫发布-订阅模式，定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知，并且自动更新

优缺点

优点：

1.主题与观察者之间松耦合

2.支持广播

缺点：

1.目标与观察者之间的依赖关系并没有完全解除，而且可能出现循环引用

2.当观察者多时，通知花费很多时间，影响效率

3.采用顺序通知，如果某一观察者卡住，其他将无法接收消息

结构

角色：

抽象主题角色：被观察的对象，定义了一个观察者集合

具体主题角色：具体目标类，实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象

抽象观察者角色：一个抽象类或接口，它包含了一个更新自己的方法，当接到更改通知时被调用

具体观察者角色：实现抽象观察者中定义的抽象方法，以便在得到目标更改通知时被调用

实现

1.被观察者

public interface Subject{//被观察者创建3个方法：添加监听者、删除监听者、通知监听者public void register(Observer observer);public void remove(Observer observer);public void notifyAll();public abstract void doSomething();
}

2.具体观察者

public class ConcreteSubject implements Subject {private List<Observer> observers = new ArrayList<>();@Overridepublic void register(Observer observer){observers.add(observer);}@Overridepublic void remove(Observer observer){observers.remove(observer);}@Overridepublic void notifyAllObserver(){for (Observer observer : observers){observer.update();}}@Overridepublic void doSomething(){this.notifyAllObserver();}
}

3.观察者

public interface Observer{public void update();
}

4.具体观察者

public class Concrete2 implements Observer{@Overridepublic void update(){System.out.println("收到消息！");}
}

运用场景

1.对一个对象状态的更新需要同步给其他对象，而且其他对象的数量是动态可变的

2.系统存在事件多级触发时

3.对象仅需通知自己更新的通知，而不需要知道其他对象的细节

访问者模式

简介

在不改变聚合对象内元素的前提下，为聚合对象内每个元素提供多种访问方式，即聚合对象内的每个元素都有多个访问者对象

优缺点

优点：

符合单一职责原则，即数据的存储和操作分别由对象结构类和访问者类实现

优秀的扩展性和灵活性

缺点：

具体元素对访问者公布了其细节

具体元素的增加将导致访问者类的修改

访问者类依赖了具体类而不是抽象

结构

        抽象元素：定义接受访问者的行为。
        具体元素：实现抽象访问者，实现其定义的接受访问者的行为，并将访问行为委托给接受的访问者对象。
        抽象访问者：定义访问不同元素的行为。即当系统中有多个不同类型的元素时，抽象访问者则需要定义多个访问行为。
        具体访问者：实现抽象访问者，实现其定义的多个访问不同元素的行为。
        对象结构：即聚合对象，持有一个抽象元素的聚合引用，并提供添加元素、获取元素、移除元素、访问元素的方法

实现

抽象元素：public interface Element {/*** 接受访问者* @param visitor*/void accept(Visitor visitor);
}//具体元素一
public class OneElement implements Element {@Overridepublic void accept(Visitor visitor) {visitor.visitor(this);}
}//具体元素二
public class TwoElement implements Element {@Overridepublic void accept(Visitor visitor) {visitor.visitor(this);}
}抽象访问者：
public interface Visitor {/*** 访问元素一* @param oneElement*/void visitor(OneElement oneElement);/*** 访问元素二* @param twoElement*/void visitor(TwoElement twoElement);
}具体访问者一：
public class OneVisitor implements Visitor {@Overridepublic void visitor(OneElement oneElement) {System.out.println("访问者一访问元素一 " + oneElement);}@Overridepublic void visitor(TwoElement twoElement) {System.out.println("访问者一访问元素二 " + twoElement);}
}具体访问者二：
public class TwoVisitor implements Visitor {@Overridepublic void visitor(OneElement oneElement) {System.out.println("访问者二访问元素一 " + oneElement);}@Overridepublic void visitor(TwoElement twoElement) {System.out.println("访问者二访问元素二 " + twoElement);}
}对象结构：
public class ObjectStructure {private List<Element> elements;public ObjectStructure() {this.elements = new ArrayList<>();}public void add(Element element) {this.elements.add(element);}public Element get(Integer index) {return this.elements.get(index);}public void remove(Element element) {this.elements.remove(element);}/*** 访问对象内元素* @param visitor*/public void accept(Visitor visitor) {for (Element element : this.elements) {element.accept(visitor);}}
}测试：
public class VisitorTest {public static void main(String[] args) {ObjectStructure objectStructure = new ObjectStructure();objectStructure.add(new OneElement());objectStructure.add(new OneElement());objectStructure.add(new TwoElement());objectStructure.add(new TwoElement());objectStructure.accept(new OneVisitor());System.out.println();objectStructure.accept(new TwoVisitor());}
}

运用场景

当对象结构相对稳定，但其操作算法经常变化时

当需要为对象结构中的元素提供多个不同且不想管的操作，且要避免让这些操作的变化影响对象的结构时

模板方法模式

简介

定义一个模版结构即抽象，将具体内容延迟到子类去实现

优缺点

优点：

提高代码复用性

提高了拓展性

实现了反向控制

缺点：

引入了抽象类，每一个不同的实现都需要一个子类来实现，导致类的个数增加，从而增加了系统实现的复杂度

结构

角色：

抽象类角色：定义了一个或多个抽象操作，以便让子类实现。这些抽象操作叫做基本操作，它们是一个顶级逻辑的组成步骤

具体子类角色：实现父类所定义的一个或多个抽象方法，它们是一个顶级逻辑的组成步骤

实现

1.抽象类

package com.charon.template;/*** @className: Account* @description:* @author: charon* @create: 2022-03-26 14:57*/
public abstract class Account {private String accountNum;/*** 无参构造，帮助子类初始化* 如果没有显示声明父类的无参的构造方法，系统会自动默认生成一个无参构造方法。* 但是，如果声明了一个有参的构造方法，而没有声明无参的构造方法，这时系统不会动默认生成一个无参构造方法。*/public Account() {}public Account(String accountNum) {this.accountNum = accountNum;}/*** 模板方法，计算利息的数额* 使用final修饰，可以防止子类重写模板方法* @return*/public final double calcInterest(){double interestRate = calcInterestRate();String accountType = calcAccountType();double amount = getAmount(accountType,accountNum);return interestRate * amount;}/*** 获取账户金额* @param accountType 账户类型* @param accountNum 账号* @return*/protected double getAmount(String accountType, String accountNum){// 从数据库中获取该账户的金额,这里直接返回一个return 5000;}/*** 计算账户类型*/protected abstract String calcAccountType();/*** 计算利息利率* @return*/protected abstract double calcInterestRate();
}

2.子类

package com.charon.template;/*** @className: MoneyMarketAccount* @description:* @author: charon* @create: 2022-03-26 15:12*/
public class MoneyMarketAccount extends Account{@Overrideprotected String calcAccountType() {return "Money Market";}@Overrideprotected double calcInterestRate() {return 0.045;}
}package com.charon.template;/*** @className: CDAccount* @description:* @author: charon* @create: 2022-03-26 15:22*/
public class CDAccount extends Account {@Overrideprotected String calcAccountType() {return "CD";}@Overrideprotected double calcInterestRate() {return 0.065;}
}

3.调用

package com.charon.template;/*** @className: Client* @description: * @author: charon* @create: 2022-03-25 23:44*/
public class Client {public static void main(String[] args) {Account mmAccount = new MoneyMarketAccount();System.out.println("货币市场账号的利息是：" + mmAccount.calcInterest());Account cdAccount = new CDAccount();System.out.println("定期账号的利息是：" + cdAccount.calcInterest());}
}打印：货币市场账号的利息是：225.0定期账号的利息是：325.0