观察者模式(Observer)

一.观察者模式定义：

对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都得到通知并自动更新

二.观察者模式的结构说明：

1.Subject：目标对象

a.一个目标可以被多个观察者观察

b.目标可以提供添加和删除观察者，方便维护观察者

c.当目标的状态发生改变时，目标负责通知所有注册的，有效的观察者

2.Observer：定义观察者的接口，提供目标通知对应的更新方法，这个更新进行相应的业务处理

三.观察者模式的示例代码：

//Subject类

public class Subject {
	private List<Observer> observers=new ArrayList<Observer>();
	//注册观察者
	public void addObserver(Observer observer){
		observers.add(observer);
	}
	//删除观察者
	public void removeObserver(Observer observer){
		observers.remove(observer);
	}
	//通知所有的观察者
	public void nodifyAllObserver(){
		for(Observer observer:observers){
			observer.update(this);
		}
	}
}

//Observer接口

public interface Observer {
	public void update(Subject subject);
}

四.使用观察者模式的实现示例代码：

报社发布报纸，读者阅读报纸

//阅读者类

public class Reader implements Observer{//这个观察者是引入自己的观察者，不是引入jdk的观察者
	private String name=null;

	@Override
	public void update(Subject subject) {
		//收到通知后，回调目标的信息
		System.out.println(name+"收到报纸了，阅读它，内容是："+((NewsPapper)subject).getContent());
	}
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
}

//报纸类

public class NewsPapper extends Subject{
	private String content=null;

	
	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
		
		//内容修改后，通知所有的监听者 
		this.nodifyAllReaders();
	}

}

//客户端测试

public class Client {
	public static void main(String[] args) {
		//创建阅读者
		Reader reader1=new Reader();
		reader1.setName("张三");
		Reader reader2=new Reader();
		reader2.setName("李四");
		Reader reader3=new Reader();
		reader3.setName("王五");
	
		NewsPapper papper=new NewsPapper();
		
		//注册阅读者
		papper.addReaders(reader1);
		papper.addReaders(reader2);
		papper.addReaders(reader3);
		
		//要出报纸啦
		papper.setContent("本期内容是观察者模式实例演示");
		
	}

}

五.简单模拟jdk实现的awt观察者模式：

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


//事件类  
class ActionEvent {  
        private long when;//事件发生的时间  
    private Object source;//事件源  
      
    public ActionEvent(long when, Object source) {  
        super();  
        this.when = when;  
        this.source = source;  
    }  
  
    public long getWhen() {  
        return when;  
    }  
  
    public Object getSource() {  
        return source;  
    }  
  
    public void setWhen(long when) {  
        this.when = when;  
    }  
  
    public void setSource(Object source) {  
        this.source = source;  
    }  
      
}  
  
//定义监听按钮的接口  
interface ActionListener {  
    public void actionPeformed(ActionEvent e);  
}  
  
//实现2个监听者  
class MyActionListener implements ActionListener {  
  
    @Override  
    public void actionPeformed(ActionEvent e) {  
        System.out.println("button pressed!!!");  
    }  
  
}  
  
  
class MyActionListener2 implements ActionListener {  
  
    @Override  
    public void actionPeformed(ActionEvent e) {  
        System.out.println("button pressed 2!!!");  
    }  
  
}  
  
//模拟按钮类  
class Button {  
    private List<ActionListener> actionListeners=new ArrayList<ActionListener>();  
    public void buttonPressed(){  
        for (ActionListener actionListener : actionListeners) {  
            actionListener.actionPeformed(new ActionEvent(System.currentTimeMillis(),this));  
        }  
    }  
    //注册监听者  
    public void addActionListener(ActionListener l){  
        actionListeners.add(l);  
    }  
      
}  
  
//测试  
public class Test {  
  
    public static void main(String[] args) {  
        Button b=new Button();  
          
        MyActionListener mal=new MyActionListener();  
        MyActionListener2 mal2=new MyActionListener2();  
        //注册监听  
        b.addActionListener(mal);  
        b.addActionListener(mal2);  
          
        b.buttonPressed();//发生按钮事件  
    }  
  
}

当然，jdk也提供了观察者模式，方便时，可直接查看jdk实现的观察者模式，鉴于是学习观察者模式，还是自己尝试着理解一下，方便以后复习

本文参考了《研磨设计模式》一书，以及马士兵老师的视频，特此声明！