首页 > 代码库 > 设计模式总结1--observer pattern

设计模式总结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中内置的

设计模式总结1--observer pattern