设计模式总结1--observer pattern
<!-- 设计模式 -->
<!--是一套被反复使用、多数人知
晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了
可重用代码、让代码更容易被他人理解、保证代 码可靠性 -->
-------------------------------------------------------------
<!-- 观察者模式 observer patterns-->
<!-- 对于天气预报的举例，首先这是常规的方法 -->
public class WeatherData {
private int low;
private int height;
private String weather;
public int getLow() {
return low;
}
public int getHeight() {
return height;
}
public String getWeather() {
return weather;
}
public void setData(int low,int height,String weather){
this.low = low;
this.height = height;
this.weather = weather;
change();
}
private void change() {
Xiaomi xiaomi = new Xiaomi();
xiaomi.disPlay(getLow(),getHeight(),getWeather());
Chuizi chuizi = new Chuizi();
chuizi.disPlay(getLow(),getHeight(),getWeather());
}
}
public class Xiaomi {
public void disPlay(int low, int height, String weather) {
System.out.println(low + ":" + height + ":" + weather);
}
}
public class Chuizi {
public void disPlay(int low, int height, String weather) {
System.out.println(low + ":" + height + ":" + weather);
}
}
但是这是有问题的，不够灵活，有的厂商想加上这个功能，有的厂商想去掉这个功能
就像报纸
出版社的任务就是出报纸
你订阅了出版社的报纸，出版社就会将新的报纸给你送
你不需要该出版社的报纸，可以取消订阅
只要出版社还在，就会一直有很多人取消或订阅报纸
观察者模式
定义了对象间一对多的依赖，这样一来，当一个对象的状态改变时，
它的所有依赖都会自动收到通知并自动更新
报社是主题，订阅者是观察者对象
/*定义一个主题接口*/
public interface Subject {
public void addObserver(Observer observer);
public void removeObserver(Observer observer);
public void notifyObserver();
}
/*主题要继承自主题接口，用于添加一些对观察者操作的几个方法*/
public class WeatherData implements Subject{
private int low;
private int height;
private String weather;
//定义一个list，用于存放所有观察者，方便下面进行通知
private List<Observer> list = new ArrayList<Observer>();
public int getLow() {
return low;
}
public int getHeight() {
return height;
}
public String getWeather() {
return weather;
}
public void setData(int low,int height,String weather){
this.low = low;
this.height = height;
this.weather = weather;
//通知观察者
notifyObserver();
}
//对观察者进行添加
@Override
public void addObserver(Observer observer) {
if(observer == null){
return;
}
if(!list.contains(observer)){
list.add(observer);
}
}
//通知所有观察者
@Override
public void notifyObserver() {
for(Observer o : list){
o.update(getLow(), getHeight(), getWeather());
}
}
//删除观察者
@Override
public void removeObserver(Observer observer) {
list.remove(observer);
}
}
/*定义一个观察者接口,观察者在继承之后要实现他的方法用于更新数据*/
public interface Observer {
public void update(int low,int height,String weather);
}
public class Xiaomi implements Observer{
/**
* 对于观察者，我希望做到不管是添加该业务还是取消，主题端是不管的，所以
* 定义构造方法，new出来这个对象的时候自动加入到被通知列（成为观察者），
* 同时还设有取消该业务
*/
private Subject subject;
public Xiaomi(Subject subject){
this.subject = subject;
subject.addObserver(this);
}
public void cancle(){
subject.removeObserver(this);
}
public void disPlay(int low, int height, String weather) {
System.out.println(low + ":" + height + ":" + weather);
}
@Override
public void update(int low, int height, String weather) {
disPlay(low,height,weather);
}
}
public class Chuizi implements Observer{
private Subject subject;
public Chuizi(Subject subject){
this.subject = subject;
subject.addObserver(this);
}
public void cancle(){
subject.removeObserver(this);
}
public void disPlay(int low, int height, String weather) {
System.out.println(low + ":" + height + ":" + weather);
}
@Override
public void update(int low, int height, String weather) {
disPlay(low,height,weather);
}
}
测试运行
public class test {
public static void main(String[] args) {
WeatherData data = new WeatherData();
<!-- 加入该业务 -->
Xiaomi xiaomi = new Xiaomi(data);
Chuizi chuizi = new Chuizi(data);
<!-- 两个都通知 -->
data.setData(1, 10, "晴朗");
<!-- 取消该业务 -->
xiaomi.cancle();
<!-- 只通知一个 -->
data.setData(2, 12, "晴朗");
}
}
======================================================================
======================================================================
======================================================================
java中内置的观察者模式
在这里不是实现了而是继承
public class WeatherData extends Observable {
private int low;
private int height;
private String weather;
public int getLow() {
return low;
}
public int getHeight() {
return height;
}
public String getWeather() {
return weather;
}
public void setData(int low,int height,String weather) {
this.low = low;
this.height = height;
this.weather = weather;
change();
}
public void change() {
/*Observable，可以点击进入Observable看里面的方法，首先setChanged（）将changed属性改为true
代表有改变*/
setChanged();
/* 通知观察者 */
<!-- 方式1 -->
notifyObservers();
<!-- 方式2 -->
notifyObservers(new Object[]{getLow(),getHeight(),getWeather()});
}
}
import java.util.Observable;
import java.util.Observer;
public class Htc implements Observer{
/*构造方法，将自己加入通知列*/
private Observable observable;
public Htc(Observable observable) {
this.observable = observable;
observable.addObserver(this);
}
/*取消该业务 */
public void cancel() {
observable.deleteObserver(this);
}
public void display(int low,int height,String weather) {
System.out.println("HTC 最低温度:" + low + " 最高温度:" + height + " 天气：" + weather);
}
@Override
public void update(Observable o, Object arg) {
/*
拉模式：当要使用的时候再获取
对应上面的方式1 当创建weatherdata的时候会执行父类的构造方法 这个o是从父类中
传过来的（传的是this），所以这个o指的是weatherdata本身，强制转换*/
WeatherData wd = (WeatherData) o;
display(wd.getLow(), wd.getHeight(), wd.getWeather());
/*
推模式：不管你用不用，我先给你
对应上面的方式2 当使用notifyObservers(new Object[]{getLow(),getHeight(),getWeather()});
arg不为null*/
if(arg != null) {
Object[] array = (Object[]) arg;
display(Integer.parseInt(array[0].toString()), Integer.parseInt(array[1].toString()), array[2].toString());
}
}
}
测试
public class Test {
public static void main(String[] args) {
WeatherData wd = new WeatherData();
Htc htc = new Htc(wd);
wd.setData(2, 8, "晴天");
}
}
----------------------------------------------------------------------
----------------------------------------------------------------------
对于要使用自己写的还是java内置的？
java中的主题是要继承的而不是实现的，所以当他已经有了父类的时候就不能再继承其他类
Observable是一个类，主题类只能继承该类，如果主题类已经有
了父类，则无法完成观察者模式，因为Java不支持多继承。
关于观察者模式
该模式定义了对象之间一对多的关系
主题用一个共同的接口来更新观察者
主题和观察者之间用松耦合的方式结合，主题不知道观察者的细节，只知道观察者实现了观察者接口
java中内置了观察者模式
知道使用Java中内置观察者模式的缺点
如有必要，尽量自己实现观察者模式，而不是使用Java中内置的
