观察者模式定义了一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象发生改变时,会通知所有观察者对象,使他们能够自动更新自己
缺点:需要维护相关对象间的一致性。我们不希望为了维持一致性而使各类紧密耦合,这样会给维护、扩展和重用都带来不便
优点:相互耦合,让耦合的双方都依赖于抽象,而不是具体依赖于具体,从而使得各自的变化都不会影响另一边的变化
观察者类一般有增加观察者。减少观察者,通知,通知者状态四个方法。
其他类实现观察这类四个方法
UML:
JAVA:
public class ObserverTest {
public static void main(String[] args) {
Boss boss = new Boss();
Observer observer1 = new StockObserver("lili",boss);//lili,观察boss
Observer observer2 = new StockObserver("lilei",boss);//lilei,观察boss
boss.attach(observer1);
boss.attach(observer2);
boss.detach(observer2);
boss.setSubjectState(true);
boss.notifying();
}
}
//抽象观察者
abstract class Observer{
protected String name;
protected Subject sub;
public Observer(String name, Subject sub) {
this.name = name;
this.sub = sub;
}
public abstract void Update();
}
//例如看股票的同事 在观察老板有没有回来
class StockObserver extends Observer{
public StockObserver(String name, Subject sub) {
super(name, sub);
}
@Override
public void Update() {
System.out.println(sub.getSubjectState()+" "+name+" 关闭股票行情,继续工作");
}
}
//通知者
interface Subject{
void attach(Observer observer);
void detach(Observer observer);
void notifying();
boolean getSubjectState();
void setSubjectState(boolean subjectState);
}
class Boss implements Subject{
List<Observer> observers = new ArrayList<>();
boolean subjectState = false; //true在,false不在
@Override
public void attach(Observer observer) {
observers.add(observer);
}
@Override
public void detach(Observer observer) {
observers.remove(observer);
}
@Override
public void notifying() {
for (Observer o:observers ) {
o.Update();
}
}
@Override
public boolean getSubjectState() {
return subjectState;
}
@Override
public void setSubjectState(boolean subjectState) {
this.subjectState = subjectState;
}
}