设计模式-观察者模式

观察者模式：在对象之间定义一对多的依赖，当对象的状态发生改变时，依赖对象就会收到通知自动更新。
我们先看看jdk提供的观察者模式到底该如何使用。首先定义一个类集成java.util.Observable,然后在状态变化的时候调用setChanged方法改变观察者内部的标志位，最后发送通知让观察者进行对应的逻辑操作

public class Student extends Observable {

    private String name;

    private String sex;

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
        setChanged();
        notifyObservers();
    }
}

观察者需要实现java.util.Observer接口，在update方法中接收变化后的新对象

public class StudentObserver implements java.util.Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println(o);
    }
}
public class StudentMain {


    public static void main(String[] args){
        Student student = new Student();
        student.addObserver(new StudentObserver());
        student.setName("HELLO");
        student.setSex("MALE");


    }
}

以上是jdk提供的观察者模式的实现，但是了在使用的过程中却不是那么方便，首先Observable是一个类，java中只能单继承，那么一旦被观察的对象需要集成其他的父类时，就显得很累赘，那怎么办了，其实在了解该模式的原理后完全可以自己来实现。

public interface Subject extends Serializable{

    public List<Observer> observerList = new ArrayList<Observer>();

    public void addObserver(Observer observer);

    public void removeObserver(Observer observer);

    public void notifyObservers(String key);
}

public interface Observer<T> {

    public void update(T current,String key);
}

public class Person implements Subject {

    private String name;

    private String sex;

    private int age;

    @Override
    public void addObserver(Observer observer) {
        observerList.add(observer);
    }

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

    @Override
    public void notifyObservers(String key) {
        for (Observer item: observerList) {
            item.update(this,key);
        }
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
        notifyObservers("sex");

    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
        notifyObservers("age");
    }
}

public class PersonObserver implements Observer<Person> {

    @Override
    public void update(Person current,String key) {
        System.out.println("changed"+"   "+ key);
    }
}

public class PersonMain {

    public static void main(String[] args){
        Person person = new Person();
        person.addObserver(new PersonObserver());
        person.setAge(20);
        person.setName("张三");
        person.setSex("男");

    }
}

自己实现也不是那么麻烦，但跟jdk提供的实现方式一对比，我们采用来接口的方式，扩展性要好很多，但是需要在被观察的每个子类中都要实现固定的逻辑，这也是为什么jdk提供的是类而非接口了，小伙伴可以根据自己的业务需要选择具体的实现方式