试想一段业务逻辑：如果孩子哭，则做点什么；不哭就啥也不做，一直观察。

v1：披着面向对象外衣的面向过程

public class Main1 {public static void main(String[] args) {boolean cry = false;while (!cry) {//进行处理}if(cry){//do sth}}
}

v2：面向对象的方式

class Child {private boolean cry = false;public boolean isCry() {return cry;}public void wakeUp() {System.out.println("Wake Up! Crying wuwuwuwuwuwu......");cry = true;}}public class Main {public static void main(String[] args) {Child child = new Child();while (!child.isCry()) {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("observer ....");}}}

v3：将观察者放在被观察者里面里面

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 wuwuwuwuwuwu......");cry = true;d.feed();}}class Dad {public void feed() {System.out.println("dad feeding...");}
}/*** 孩子哭了，老爸观察到后便去喂奶，孩子为被观察者*/
public class Main {public static void main(String[] args) {Child child = new Child();//do sthchild.wakeUp();}}

v4：多个观察者

class Child {private boolean cry = false;private Dad dad = new Dad();private Mum mum = new Mum();private Dog dog = new Dog();public boolean isCry() {return cry;}public void wakeUp() {cry = true;dad.feed();mum.hug();dog.wang();}}class Dad {public void feed() {System.out.println("dad feeding...");}
}class Mum {public void hug() {System.out.println("mum huging...");}
}class Dog {public void wang() {System.out.println("dog wang...");}
}public class Main {public static void main(String[] args) {Child child = new Child();//do sthchild.wakeUp();}
}

v5：使用观察者模式

interface Observer {void actionOnWake();}class Dad implements Observer {@Overridepublic void actionOnWake() {System.out.println("dad feeding...");}
}class Mum implements Observer {@Overridepublic void actionOnWake() {System.out.println("mum hug...");}
}class Dog implements Observer {@Overridepublic void actionOnWake() {System.out.println("dog wang...");}
}class Child {private List observers = new ArrayList<>();{observers.add(new Dad());observers.add(new Mum());observers.add(new Dog());}private boolean cry = false;public boolean isCry() {return cry;}public void wakeUp() {cry = true;for (Observer observer : observers) {observer.actionOnWake();}}}public class Main {public static void main(String[] args) {Child child = new Child();//do sthchild.wakeUp();}
}

v6：带有事件传递的观察者

class WakeUpEvent {long timestamp;String loc;public WakeUpEvent(long timestamp, String loc) {this.timestamp = timestamp;this.loc = loc;}
}interface Observer {void actionOnWake(WakeUpEvent event);
}class Dad implements Observer {@Overridepublic void actionOnWake(WakeUpEvent event) {System.out.println("dad feeding...");}
}class Mum implements Observer {@Overridepublic void actionOnWake(WakeUpEvent event) {System.out.println("mum hug...");}
}class Dog implements Observer {@Overridepublic void actionOnWake(WakeUpEvent event) {System.out.println(event.timestamp + "----" + event.loc + "dog wang...");}
}class Child {private List observers = new ArrayList<>();{observers.add(new Dad());observers.add(new Mum());observers.add(new Dog());}private boolean cry = false;public boolean isCry() {return cry;}public void wakeUp() {cry = true;WakeUpEvent event = new WakeUpEvent(System.currentTimeMillis(), "地上");for (Observer observer : observers) {observer.actionOnWake(event);}}}public class Main {public static void main(String[] args) {Child child = new Child();//do sthchild.wakeUp();}
}

v7：将被观察者（事件源）传递给观察者

class WakeUpEvent {long timestamp;String loc;Child source;public WakeUpEvent(long timestamp, String loc, Child source) {this.timestamp = timestamp;this.loc = loc;this.source = source;}
}interface Observer {void actionOnWake(WakeUpEvent event);
}class Dad implements Observer {@Overridepublic void actionOnWake(WakeUpEvent event) {System.out.println("dad feeding...");}
}class Mum implements Observer {@Overridepublic void actionOnWake(WakeUpEvent event) {System.out.println("mum hug...");}
}class Dog implements Observer {@Overridepublic void actionOnWake(WakeUpEvent event) {System.out.println(event.source + "dog wang...");}
}class Child {private List observers = new ArrayList<>();{observers.add(new Dad());observers.add(new Mum());observers.add(new Dog());}private boolean cry = false;public boolean isCry() {return cry;}public void wakeUp() {cry = true;WakeUpEvent event = new WakeUpEvent(System.currentTimeMillis(), "地上", this);for (Observer observer : observers) {observer.actionOnWake(event);}}}/*** 有很多时候，观察者需要根据事件的具体情况来进行处理（事件源对象不同，处理逻辑不同）* 大多数时候，我们处理事件的时候，需要拿到事件源对象* 事件源对象，怎么传递？* 1、直接写死在Observer中肯定是不行的，这样就定死了观察对象。* 2、可以通过event传递过去*/
public class Main {public static void main(String[] args) {Child child = new Child();//do sthchild.wakeUp();}
}

/*** 例如JFrame中的事件源Source*/
public class JFrameText {public static void main(String[] args) {JFrame frame = new JFrame();FlowLayout flowLayout = new FlowLayout(FlowLayout.LEFT);frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);frame.setBounds(100, 100, 700, 500);//水平间距flowLayout.setHgap(20);//控件之间的垂直间距flowLayout.setVgap(20);JPanel panel = new JPanel(flowLayout);JButton btnSend = new JButton("按钮");btnSend.setEnabled(true);panel.add(btnSend);frame.getContentPane().add(panel);frame.setVisible(true);//ActionListener为观察者btnSend.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {System.out.println(e.getSource() + "按钮被点击了");}});btnSend.addKeyListener(new KeyListener() {@Overridepublic void keyTyped(KeyEvent e) {}@Overridepublic void keyPressed(KeyEvent e) {}@Overridepublic void keyReleased(KeyEvent e) {}});}
}

v8：事件可以做抽象多态处理

abstract class Event {abstract T getSource();
}class WakeUpEvent extends Event {long timestamp;String loc;Child source;public WakeUpEvent(long timestamp, String loc, Child source) {this.timestamp = timestamp;this.loc = loc;this.source = source;}@OverrideChild getSource() {return source;}
}interface Observer {void actionOnWake(Event event);
}class Dad implements Observer {@Overridepublic void actionOnWake(Event event) {WakeUpEvent e = (WakeUpEvent) event;Child source = e.getSource();System.out.println("dad feeding...");}
}class Mum implements Observer {@Overridepublic void actionOnWake(Event event) {System.out.println("mum hug...");}
}class Dog implements Observer {@Overridepublic void actionOnWake(Event event) {System.out.println("dog wang...");}
}class Child {private List observers = new ArrayList<>();{observers.add(new Dad());observers.add(new Mum());observers.add(new Dog());}private boolean cry = false;public boolean isCry() {return cry;}public void wakeUp() {cry = true;Event event = new WakeUpEvent(System.currentTimeMillis(), "地上", this);for (Observer observer : observers) {observer.actionOnWake(event);}}}public class Main {public static void main(String[] args) {Child child = new Child();//do sthchild.wakeUp();}
}

v9：利用观察者模式仿照写一个JFrame

public class Test {public static void main(String[] args) {Button b = new Button();b.addActionListener(new MyActionListener1());b.addActionListener(new MyActionListener2());b.buttonPressed();}
}class Button {private List actionListeners = new ArrayList<>();public void buttonPressed() {ActionEvent e = new ActionEvent(System.currentTimeMillis(), this);for (int i = 0; i < actionListeners.size(); i++) {ActionListener l = actionListeners.get(i);l.actionPerformed(e);}}public void addActionListener(ActionListener listener) {actionListeners.add(listener);}}class ActionEvent {long when;Object source;public ActionEvent(long when, Object source) {this.when = when;this.source = source;}
}interface ActionListener {//Observervoid actionPerformed(ActionEvent e);
}class MyActionListener1 implements ActionListener {@Overridepublic void actionPerformed(ActionEvent e) {System.out.println("button pressed 1!");}
}class MyActionListener2 implements ActionListener {@Overridepublic void actionPerformed(ActionEvent e) {System.out.println("button pressed 2!");}
}

/*** 对照原生的JFrame中的Button*/
public class TestFrame extends Frame {public void launch() {Button button = new Button("press me");button.addActionListener(new MyActionListener());button.addActionListener(new MyActionListener2());this.add(button);this.pack();this.addWindowListener(new WindowAdapter() {@Overridepublic void windowClosed(WindowEvent e) {System.exit(0);}});this.setLocation(400, 400);this.setVisible(true);}public static void main(String[] args) {new TestFrame().launch();}class MyActionListener implements ActionListener {//Observer@Overridepublic void actionPerformed(ActionEvent e) {System.out.println("button pressed!");}}class MyActionListener2 implements ActionListener {@Overridepublic void actionPerformed(ActionEvent e) {System.out.println("button pressed 2!");}}}

附：

• javascript中的 event对象也是一种观察者

• 在很多系统中，Observer模式往往和责任链模式共同负责对事件的处理，其中的某一个observer负责是否将事件进一步传递

• 观察者的应用：响应式编程，如RxJava

 io.reactivex.rxjava2rxjava2.2.21

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.annotations.NonNull;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;public class HelloRx {public static void main(String[] args) {
//        test1();test2();}private static void test1() {//1、产生事件：事件源对象，实现subscribe方法，在其中产生事件Observable observable = Observable.create(new ObservableOnSubscribe() {@Overridepublic void subscribe(@NonNull ObservableEmitter emitter) throws Exception {//发射器发射事件emitter.onNext("hello");emitter.onNext("world");}});//2、消费者Consumer consumer = new Consumer() {@Overridepublic void accept(String s) throws Exception {System.out.println(Thread.currentThread().getName() + " == consumer ==" + s);}};//3、同步解耦合（类似mq,mq是拉，这个是推）observable.subscribe(consumer);//4、异步observable.observeOn(Schedulers.newThread()).subscribe(consumer);//5、观察者，比更消费者consumer更加灵活的处理Observer observer = new Observer() {@Overridepublic void onSubscribe(@NonNull Disposable disposable) {}@Overridepublic void onNext(String s) {System.out.println(Thread.currentThread().getName() + " == observer ==" + s);}@Overridepublic void onError(Throwable throwable) {}@Overridepublic void onComplete() {}};//6、同步observable.subscribe(observer);//7、异步observable.observeOn(Schedulers.newThread()).subscribe(observer);}private static void test2() {//以上的逻辑可以写成链式Observable.create((ObservableOnSubscribe) emitter -> {emitter.onNext("hello");emitter.onNext("world");}).observeOn(Schedulers.newThread()).subscribe(s -> System.out.println(Thread.currentThread().getName() + " == consumer ==" + s));}}

public class Main {public static void main(String[] args) {Observable.create(new ObservableOnSubscribe() {@Overridepublic void subscribe(@NonNull ObservableEmitter emitter) throws Exception {emitter.onNext("hello");emitter.onNext("world");}}).subscribe(new Consumer() {@Overridepublic void accept(String s) throws Exception {System.out.println(s);}});}
}