码农小汪-设计模式之-观察者模式 依赖倒置原则

观察者模式

观察者模式属于 行为型模式。（嘎嘎嘎，刚刚吃饭哦！）

这个模式太常见了吧。我们的onclick…很典型的！通知你啊。大话设计模式中举得例子键值太经典了，越看越好笑，但是确实是说到了点子上去了。看过很多次了。这是没有把他书写出来。增加自己的意识。以后复习的时候也是比较方便的复习！

大话设计模式例子：

很简单，前台的妹子，看经理走了没得，这些工作人员在那里讨论股票的事情，如果经理来了呢，前台妹子通知这些人，赶紧的恢复次序好好的工作。这个和我们的订阅，发送差不多。就是一个道理。如果你订阅了我的邮件，当我有新的内容更新的时候，我就会发送给你涩。这个就是通知我嘛！你懂得！

双向耦合的哦

什么叫双向的耦合，之前我学习Hibernate的时候，有个双向关联，1-N的双向关联。双方都依赖于对方哦。

一面是@OneToMany 这个就是前台妹子吧 里面有个集合对象~

一面是@ManyToOne IT工作者吧

复习回忆一下！我们底层数据库的实现其实可以有连接表，和不需要连接表的两种形式。一般让我们的one方维护关系！

讲偏我们的学习的方向啦~~对哈！双向的关联，都要向对方注入依赖关系。

这里讲一下：依赖倒置原则抽象应该不应该依赖于细节，细节应该依赖于抽象。就是针对接口编程，不要对实现编程。

还有个就是：我们高层的模块不应该依赖于底层模块，两个都应该依赖于抽象。（比如我们做项目访问数据库，把访问数据库的都改成函数，每次调用的时候就去使用这些函数，这个就是高层依赖于底层模块） 假如我们客服希望我们换一种数据库怎么办呢？没办法啊，没办法复用高层模块！

//看看就好了，理论的东西！慢慢的理解

优点： 1、观察者和被观察者是抽象耦合的。 2、建立一套触发机制。

缺点： 1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。 2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。 3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

例子：

观察者模式使用三个类 Subject、Observer 和 Client。Subject 对象带有绑定观察者到 Client 对象和从 Client 对象解绑观察者的方法。我们创建 Subject 类、Observer 抽象类和扩展了抽象类 Observer 的实体类。

其实我们的Subject也是应该抽象的， 如果多个通知者。在大话设计模式中有讲过，假如多个通知者来了，怎么办呢？老板和前台妹子都是有可能成为通知者，所以我们可以这么处理。



前台的妹子哦，我们要向她绑定哦，绑定过了，人家才会通知你。好比你要和她搭理好关系哦

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

public class Subject {

private List<Observer> observers //那一群汉子
= new ArrayList<Observer>();
private int state;

public int getState() {
return state;
}

public void setState(int state) {
this.state = state;
notifyAllObservers();//一有 动静，就去通知欧
}

public void attach(Observer observer){// 订阅差不多的意思！
observers.add(observer);
}

public void notifyAllObservers(){//通知所以得人
for (Observer observer : observers) {
observer.update();
}
}
}

观察者，感觉这个名字取得不好。不应是观察者，应该是被通知的对象哦。订阅者之类的。就是我们那些汉子！抽象哦，为啥。自己考虑

public abstract class Observer {
protected Subject subject;
public abstract void update();
}

具体的类，可能是Java开发中，可能是游戏开发者，可能是C++开发者

可能是其他的哦….美工妹子也有可能。

public class BinaryObserver extends Observer{

public BinaryObserver(Subject subject){
this.subject = subject;
this.subject.attach(this);//注入依赖欧
}

@Override
public void update() {
System.out.println( "Binary String: "
+ Integer.toBinaryString( subject.getState() ) );
}
}
public class OctalObserver extends Observer{

public OctalObserver(Subject subject){
this.subject = subject;
this.subject.attach(this);
}

@Override
public void update() {
System.out.println( "Octal String: "
+ Integer.toOctalString( subject.getState() ) );
}
}

Domo

public class ObserverPatternDemo {
public static void main(String[] args) {
Subject subject = new Subject();

new HexaObserver(subject);//attach注入依赖哦！
new OctalObserver(subject);
new BinaryObserver(subject);

System.out.println("First state change: 15");
subject.setState(15);//只要有变化~老板来了！快跑~~
System.out.println("Second state change: 10");
subject.setState(10);
}
}

大话模式中的定义：

观察者模式定义了一对多的依赖关系，让多个观察者对象同时监听某一个主题对象（妹子前台），当这个主题对象发生改变的时候，会通知所有的观察者，让他们能够更新自己。

使用场景： 1、有多个子类共有的方法，且逻辑相同。 2、重要的、复杂的方法，可以考虑作为模板方法。