java实现观察者设计模式

观察者设计模式原理

观察者设计模式定义：简单的说，观察者模式定义了一个一对多的依赖关系，让一个或多个观察者对象监察一个主题对象。这样一个主题对象在状态上的变化能够通知所有的依赖于此对象的那些观察者对象，是这些观察者对象能够自动更新。

实例代码：

原始写法：

Doll类，Observer类，Person类，Subject类，testDemo类

/*
 * 
 *     具体的被观察者对象
 * 
 */
public class Doll implements Subject {

    // 被观察者维护的一个观察者对象列表
    private Vector<Observer> v = new Vector<Observer>();
    private float price;

    public Doll(float price) {
        this.price = price;
    }

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
        // 只要价格一变就通知更改数据
        notifyObserver();
    }

    @Override
    public void registerObserver(Observer o) {
        // TODO Auto-generated method stub
        // 注册观察者
        v.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        // TODO Auto-generated method stub
        // 取消观察者
        v.remove(o);
    }

    @Override
    public void notifyObserver() {
        // TODO Auto-generated method stub
        // 实现通知所有的观察者
        for (Observer o : v) {
            o.updata(price);
        }
    }

}
 

/*
 * 
 *     观察者接口
 * 
 */
public interface Observer {

    /*
     *     观察者得到更新信息的方法
     * 
     */
    public void updata(float price);
    
    
}
 

//具体的观察者对象
public class Person implements Observer{

    private String name;
    public Person(String name){
        this.name = name;
    }
    
    
    @Override
    public void updata(float price) {
        // TODO Auto-generated method stub
        System.out.println(name+"关注的商品价格已更新为:"+price);
    }
    
}
 

 

/*
 * 
 *     被观察者接口
 * 
 */
public interface Subject {
    
    // 注册观察者
    public void registerObserver(Observer o);
    // 删除观察这
    public void removeObserver(Observer o);
    //通知
    public void notifyObserver();
    
}
 

 

public class testDemo {
    
    @Test
    public void subjectTest(){
        // 创建一个被观察者对象
        Doll doll = new Doll(3000);
        Person p1 = new Person("小明");
        Person p2 = new Person("小红");
        // 将p1注册成为一个观察者
        doll.registerObserver(p1);
        doll.registerObserver(p2);
        System.out.println("第一轮促销");
        doll.setPrice(2999); // 价格开始浮动
        System.out.println("第二轮促销");
        doll.setPrice(1999); 
        System.out.println("第三轮促销");
        doll.setPrice(999); 
        doll.removeObserver(p2);
        doll.setPrice(99);
    }
    
    
}
 

 

使用java的API实现：

Doll类，Person类，testDemo类

// 通过继承Observable类实现具体的被观察者对象

public class Doll extends Observable{
    
    private float price;
    
    public Doll(float price){
        this.price = price;
    }

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
        this.setChanged();  // 通知，数据已改变
        this.notifyObservers();
    }
    
    
    
}
 

 

// 通过java.util.Observer接口实现具体的观察者对象
public class Person implements Observer{

    private String name;
    
    public Person(String name){
        this.name = name;
    }
    
    
    @Override
    public void update(Observable o, Object arg) {
        // TODO Auto-generated method stub
        if(o instanceof Doll){
            Doll doll = (Doll)o;
            System.out.println(name+"关注娃娃的价格"+doll.getPrice());
        }
    }
    
}
 

 

public class testDemo {
    
    @Test
    public void observerTest(){
        Doll doll = new Doll(3000);
        Person p1 = new Person("小明");
        Person p2 = new Person("小红");
        
        doll.addObserver(p1);
        doll.addObserver(p2);
        
        System.out.println("第一轮促销");
        doll.setPrice(2999); // 价格开始浮动
        System.out.println("第二轮促销");
        doll.setPrice(1999); 
        System.out.println("第三轮促销");
        doll.setPrice(999); 
        doll.deleteObserver(p2);
        System.out.println("第四轮促销");
        doll.setPrice(99); 
        
        
    }
    
    
}
 

观察者模式作用

1. 观察者模式在被观察者和观察者之间建立一个抽象的耦合，被观察者角色知道的只是一个具体观察者列表

由于被观察者和观察者没有紧密的耦合在一起，因此它们可以属于不同的抽象化层次，如果被观察者和观察者都被扔到一起，那么这个对象必然跨越抽象化和具体化层次

1. 观察者模式支持广播通讯，被观察者会向所有的登记过的观察者发出通知