2020-03-15

庚子鼠年 己卯月 丁巳日

描述

落实访问者模式

技术博客：https://blog.csdn.net/qq_40674583

随笔

访问者模式

参考博客：https://www.jianshu.com/p/1f1049d0a0f4

1. Visitor是抽象访问者，不同角色可以实例化这个对象，通过具体的实现类去访问其他的类

public interface Visitor {

    // 访问工程师类型
    void visit(Engineer engineer);

    // 访问经理类型
    void visit(Manager manager);

}

2. 被访问的类

public abstract void accept(Visitor visitor);

3. 具体的实现

@Override
public void accept(Visitor visitor) {
    visitor.visit(this);
}
// 这里把自己传进去就相当于告诉访问者类具体访问的那个类，需要执行那个重载的方法。

4. 通过访问者的具体类来访问其他类

import java.util.LinkedList;
import java.util.List;

public class BusinessReport {

    private List<Staff> mStaffs = new LinkedList<>();

    public BusinessReport() {
        mStaffs.add(new Manager("经理-A"));
        mStaffs.add(new Engineer("工程师-A"));
        mStaffs.add(new Engineer("工程师-B"));
        mStaffs.add(new Engineer("工程师-C"));
        mStaffs.add(new Manager("经理-B"));
        mStaffs.add(new Engineer("工程师-D"));
    }

    /**
     * 为访问者展示报表
     * @param visitor 公司高层，如CEO、CTO
     */
    public void showReport(Visitor visitor) {
        for (Staff staff : mStaffs) {
            staff.accept(visitor);
        }
    }
}

迭代者模式

参考博客：https://www.jianshu.com/p/3dd7b4e73561

迭代器模式（Iterator），提供一种方法顺序访问一个聚合对象中的各种元素，而又不暴露该对象的内部表示。

1. Iterator 接口

public interface Iterator{
    public abstract boolean hasNext();
    public abstract Object next();
}

2. 被迭代的迭代器要实现这个接口，并且这个具体的类依赖于需要被迭代的容器。

public class BookShelfIterator implements Iterator {

    private BookShelf bookShelf;
    private int index;

    public BookShelfIterator(BookShelf bookShelf) {
        this.bookShelf = bookShelf;
        this.index = 0;
    }

    public boolean hasNext() {
        if (index < bookShelf.getLength()) {
            return true;
        } else {
            return false;
        }
    }


    public Object next() {
        Book book = bookShelf.getBookAt(index);
        index++;
        return book;
    }
}

3. Aggregate 接口

public interface Aggregate{
    public abstract Iterator iterator();
}

4. 需要被迭代的类实现这个接口

public class BookShelf implements Aggregate {

    private List<Book> books;


    public BookShelf() {
        this.books = new ArrayList<Book>();
    }

    public Book getBookAt(int index) {
        return books.get(index);
    }

    public void appendBook(Book book) {
        books.add(book);
    }

    public int getLength() {
        return books.size();
    }

    public Iterator iterator() {
        return new BookShelfIterator(this);
    }
}

观察者模式

参考博客：https://baijiahao.baidu.com/s?id=1639044219412817957&wfr=spider&for=pc

观察者模式（又被称为发布-订阅（Publish/Subscribe）模式，属于行为型模式的一种，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时，会通知所有的观察者对象，使他们能够自动更新自己

从上面我们可以看到，这里面包含了两大类（主题和观察者）一共四个角色：

（1）Subject：抽象主题，他把所有观察者对象保存在一个集合里，可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。意思就是明星把所有的粉丝都保存在一个账号里面，粉丝数量不限，可以新增粉丝也可以拉黑粉丝。

（2）ConcreteSubject：具体主题，该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。意思是我们的明星一有动态，就会把消息给粉丝。

（3）Observer：抽象观察者，是观察者者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己。这就是我们所有粉丝的抽象。

（4）ConcrereObserver：具体观察者，实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态。具体每一个粉丝。

个人理解：

1. 定义抽象观察者（Observer）：抽象的粉丝，里面有一个update抽象方法。用于更新数据。

2. 具体的观察者（concreteObserver）：具体的粉丝

3. 定义抽象主题(Subject)：抽象明星

4. 具体主题（ConcreteSubject）：具体的明星

分析观察者模式

​ 观察者模式的主要优点在于可以实现表示层和数据逻辑层的分离，并在观察目标和观察者之间建立一个抽象的耦合，支持广播通信；其主要缺点在于如果一个观察目标对象有很多直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间，而且如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。