设计模式之观察者模式、访问者模式与模板方法模式

目录

观察者模式

简介

优缺点

结构

实现

运用场景

访问者模式

简介

优缺点

结构

实现

运用场景

模板方法模式

简介

优缺点

结构

实现

运用场景

---

观察者模式

简介

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

优缺点

优点：

        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 observers = new ArrayList<>();

    @Override
    public void register(Observer observer){
        observers.add(observer);
    }
    
    @Override
    public void remove(Observer observer){
        observers.remove(observer);
    }

    @Override
    public void notifyAllObserver(){
        for (Observer observer : observers){
            observer.update();
        }
    }

    @Override
    public void doSomething(){
        this.notifyAllObserver();
    }
}

3.观察者

public interface Observer{

    public void update();
}

4.具体观察者

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

运用场景

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

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

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

访问者模式

简介

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

优缺点

优点：

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

        优秀的扩展性和灵活性

缺点：

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

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

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

结构

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

实现

抽象元素：

public interface Element {

    /**
     * 接受访问者
     * @param visitor
     */
    void accept(Visitor visitor);
}

//具体元素一
public class OneElement implements Element {

    @Override
    public void accept(Visitor visitor) {
        visitor.visitor(this);
    }
}

//具体元素二
public class TwoElement implements Element {

    @Override
    public 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 {

    @Override
    public void visitor(OneElement oneElement) {
        System.out.println("访问者一访问元素一 " + oneElement);
    }

    @Override
    public void visitor(TwoElement twoElement) {
        System.out.println("访问者一访问元素二 " + twoElement);
    }
}

具体访问者二：
public class TwoVisitor implements Visitor {

    @Override
    public void visitor(OneElement oneElement) {
        System.out.println("访问者二访问元素一 " + oneElement);
    }

    @Override
    public void visitor(TwoElement twoElement) {
        System.out.println("访问者二访问元素二 " + twoElement);
    }
}

对象结构：
public class ObjectStructure {

    private List 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{

    @Override
    protected String calcAccountType() {
        return "Money Market";
    }

    @Override
    protected 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 {
    @Override
    protected String calcAccountType() {
        return "CD";
    }

    @Override
    protected 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	

运用场景

        一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现；

        各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复；

        控制子类的扩展