观察者模式学习

1.面向对象的傻等着，什么时候孩子醒了什么时候执行。

/**
 * 面向对象的傻等
 *
 */
class Child{
    private boolean cry = false;
    public boolean isCry() {
        return cry;
    }
    
    public void wakeup() {
        System.out.println("Wake up! Crying wuwuwuwuwu...");
        cry = true;
    }
}

public class App 
{
    public static void main( String[] args )
    {
        Child child = new Child();
        while(!child.isCry()) {
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            }
            System.out.println("observer ... ");
        }
    }
}

2. 加入观察者

class Child{
    private boolean cry = false;
    private Dad d = new Dad();
    public boolean isCry() {
        return cry;
    }
    
    public void wakeup() {
        System.out.println("Wake up! Crying wuwuwuwuwu...");
        d.feed();
    }
}

class Dad{
    public void feed() {
        System.out.println("Dad feeding ... ");
    }
}

public class App2 {
    public static void main(String[] args) {
        Child child = new Child();
        child.wakeup();
    }

}

从上可以看出，观察者（Dad）被放在被观察者（Child）里面了，然后一旦发生调用就会通知给观察者。

3.加入多个观察者

/**
 * 加入多个观察者
 *
 */
class Child{
    private boolean cry = false;
    private Dad dad = new Dad();
    private Mum mum = new Mum();
    private Dog dog = new Dog();
①
    public boolean cry() {
        return cry;
    }
    
    public void wakeup(){
        cry = true;
        dad.feed();
        dog.wang();
        mum.hug();
②
    }
}

class Dad{
    public void feed() {
        System.out.println("dad feeding ... ");
    }
}
class Mum{
    public void hug() {
        System.out.println("mum hugging ...");
    }
}
class Dog{
    public void wang() {
        System.out.println("dog wang ... ");
    }
}

public class App3 {
    public static void main(String[] args) {
        Child child = new Child();
        child.wakeup();
    }   
}

输出：
      dad feeding ... 
      dog wang ... 
      mum hugging ...

从上可以看出，一个被观察者可以加入多个观察者，而每个观察者的处理方式也可能不同。但是上面代码的方式不是特别好，如果需要添加新的观察者进来，则代码中①②的位置都需要修改。并且每个观察者也不一定都是耦合到被观察者上（即，有可能订阅的不是被观察者），耦合度过高。

4. 分离观察者与被观察者

import java.util.ArrayList;
import java.util.List;

/**
 * 分离观察者与被观察者
 *
 */
class Child{
    private boolean cry = false;
    // 定义一个列表来放置观察者
    private List<Observer> observers = new ArrayList<>();
    // 也可以在配置文件中配置，和初始化语句块效果一样
    {
        observers.add(new Dad());
        observers.add(new Mum());
        observers.add(new Dog());
    }
    
    public boolean cry() {
        return cry;
    }
    
    public void wakeup(){
        cry = true;
        for(Observer o: observers) {
            o.actionWakeup();
        }
    }
}

// 任何一个观察者都应该实现这个方法
// 当小孩子醒来后该执行什么动作
interface Observer{
    void actionWakeup();
}

// 定义每个观察者
class Dad implements Observer{
    public void feed() {
        System.out.println("dad feeding ... ");
    }
    @Override
    public void actionWakeup() {
        feed();
    };
}

class Mum implements Observer{
    public void hug() {
        System.out.println("mum hugging ...");
    }
    @Override
    public void actionWakeup() {
        hug();
    };
}

class Dog implements Observer{
    public void wang() {
        System.out.println("dog wang ... ");
    }
    @Override
    public void actionWakeup() {
        wang();
    };
}

public class App4 {
    public static void main(String[] args) {
        Child child = new Child();
        child.wakeup();
    }
}

输出：
      dad feeding ... 
      mum hugging ...
      dog wang ...