观察者设计模式

定义：定义了对象之间一对多的依赖，这样一来，当一个对象改变时，它所有的依赖者都会收到通知并自动更新
优点:
观察者模式解除了主题和具体观察者的耦合，让耦合的双方都依赖于抽象，而不是依赖具体。
从而使得各自的变化都不会影响另一边的变化。
缺点:
依赖关系并未完全解除，抽象通知者依旧依赖抽象的观察者。
适用场景:
当一个对象的改变需要给变其它对象时，而且它不知道具体有多少个对象有待改变时。
一个抽象某型有两个方面，当其中一个方面依赖于另一个方面，这时用观察者模式可以将
这两者封装在独立的对象中使它们各自独立地改变和复用。、

/**
 * @author: sjx
 * @date: 2018/7/28 13:22
 * @description:  图书订阅者
 */
public class BookSubject implements Subject {
    List observerList = new ArrayList<>();
    String bookName;

    @Override
    public void registerObserver(Observer observer) {
        if (!observerList.contains(observer)) {
            observerList.add(observer);
        }
    }

    @Override
    public void removeObserver(Observer observer) {
        if (observerList.contains(observer)) {
            observerList.remove(observer);
        }
    }

    @Override
    public void notifyObserver() {
        for (Observer observer : observerList) {
            observer.update(bookName);
        }
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }
}
/**
 * @Auther: sjx
 * @Date: 2018/7/28 13:14
 * @Description:
 */
public interface Observer {
    void update(String name);
    void disConnect();
}


/**
 * @author: sjx
 * @date: 2018/7/28 13:30
 * @description: 被观察者
 */
public class ReaderBook implements Observer {
    private Subject subject;

    public ReaderBook(Subject subject) {
        this.subject = subject;
    }

    public void register(){
        subject.registerObserver(this);
    }

    @Override
    public void update(String name) {
        System.out.println("新书来了，名称是" + name);
    }

    @Override
    public void disConnect() {
        subject.removeObserver(this);
    }
}

public class Main {

    public static void main(String[] args) {
        Subject subject = new BookSubject();
        Observer observer = new ReaderBook(subject);
        ((ReaderBook) observer).register();
        ((BookSubject) subject).setBookName("java");
        subject.notifyObserver();
    }
}

//java  jdk对观察者模式的支持

/**
 * @author: sjx
 * @date: 2018/7/28 13:46
 * @description: 观察者
 */
public class Teacher extends Observable {

    String info = "";

    public void setHomeWork(String work) {
        info = work;
        System.out.println("老师布置的作业是" + info);
        //设置通知时间生效
        setChanged();
        notifyObservers();
    }
    public String getInfo() {
        return info;
    }
}

/**
 * @author: sjx
 * @date: 2018/7/28 13:47
 * @description: 被观察者
 */
public class Student implements Observer {
    private String name;

    public Student(String name, Observable observable) {
        this.name = name;
        observable.addObserver(this);
    }

    @Override
    public void update(Observable o, Object arg) {
        Teacher teacher = (Teacher) o;
        System.out.println(name + "收到作业-" + teacher.getInfo());
    }
}

/**
 * @author: sjx
 * @date: 2018/7/28 13:44
 * @description: java jdk 内置观察者
 */
public class JdkMain {
    public static void main(String[] asrgs) {
        Teacher observable = new Teacher();
        Student student1 = new Student("张三",observable);
        Student student2 = new Student("李四",observable);
        Student student3 = new Student("王五",observable);
        observable.setHomeWork("第二页第六题");
        observable.setHomeWork("第三页第七题");
        observable.setHomeWork("第五页第八题");
    }
}