观察者模式的定义：观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新

考虑到如下一个场景，记者每次获得独家新闻，都需要通知人民日报和新华日报，Hi,i have a new message!

public class SpecificRepoter {	private PeopleDaily pd;	private XinHuaDaily xd;	private String msg;		public Repoter(){		this.pd = new PeopleDaily();		this.xd = new XinhuaDaily();	}		public void gotNewNews(String msg){		this.msg = msg;	}		public void notifyNewspaperOffice(){		pd.update(msg);		xd.update(msg);	}}

public class XinHuaDaily {	public void update(String message){		System.out.println("XinHua Daily got the new news!");	}}

public class PeopleDaily {	public void update(String message){		System.out.println("People Daily got the new news!");	}}

由于记者和报社之间的合约关系由记者来维护，维护方式为：和记者签订合同的报社作为记者的属性，也即具体报社类和记者类紧耦合，故合约关系的变化必然导致记者类的变化：

现在记者和人民日报的合约到期，同时和环球时报签订了新合约

顺承前面的设计方式，必须要修改记者类以适应合约关系的改变：

public class SpecificRepoter {	private XinHuaDaily xd;	private GlobalTimes gt;	private String msg;		public Repoter(){		this.xd = new XinHuaDaily();		this.gt = new GlobalTimes();	}		public void gotNewNews(String msg){		this.msg = msg;	}		public void notifyTheNewspaperOffice(){		xd.update(msg);		gt.update(msg);	}}

public class GlobalTimes {	public void update(String message){		System.out.println("Global Times got the new news!");	}}

显然这种设计的可扩展性很低，本质原因是记者类和具体报社类紧耦合

要提高程序的扩展性，则要从降低记者类和具体报社类的耦合度来下手：

设计一：

1，抽象出记者接口和报社抽象类，针对接口编程

2，记者与报社之间的合约关系不再通过记者组合具体报社类来维护。设计一个List<NewspaperOffice>来保存和记者签订合同的报社（本质原则也是封装可变化部分，但只是封装至一个List属性中，而没有单独封装至一个类中，不像设计二那么彻底），记者将不和任何特定的报社类相耦合

public interface Repoter {	public void registerNewspaperOffice(NewspaperOffice no);	public void removeNewspaperOffice(NewspaperOffice no);	public void notifyNewspaperOffice();}

public class SpecificRepoter implements Repoter {	private String msg;	private List
    
      relation;		public SpecificRepoter(){		relation = new ArrayList
     
      ();	}	public void registerNewspaperOffice(NewspaperOffice no) {		if(!relation.contains(no)){			relation.add(no);		}	}	public void removeNewspaperOffice(NewspaperOffice no) {		if(relation.contains(no)){			relation.remove(no);		}	}	public void notifyNewspaperOffice() {		if(null != relation && relation.size()>0){			for(NewspaperOffice no : relation){				no.update(this.msg);			}		}	}		public void getNewNews(String msg){		this.msg = msg;		notifyNewspaperOffice();	}}
     
    

public abstract class NewspaperOffice {	protected Repoter repoter;	protected String newMsg;		public void register(){		repoter.registerNewspaperOffice(this);	}		public void remove(){		repoter.removeNewspaperOffice(this);	}		public abstract void update(String newMsg);}

public class PeopleDaily extends NewspaperOffice{	public PeopleDaily(Repoter repoter){		this.repoter = repoter;	}		public void update(String newMsg) {		this.newMsg = newMsg;		System.out.println("People Daily got "+newMsg);	}}

具体报社类设计拥有register()和remove()方法以提高使用时的灵活性，当然这不是必要的

无论合约关系如何变化，SpecificReport类都不需要重新设计修改，相当方便

public class Test {	public static void main(String[] args){		Repoter repoter = new SpecificRepoter();		NewspaperOffice n1 = new GlobalTimes(repoter);		NewspaperOffice n2 = new XinHuaDaily(repoter);		NewspaperOffice n3 = new PeopleDaily(repoter);		n1.register();		n2.register();		repoter.registerNewspaperOffice(n3);				repoter.getNewNews("news coming!");		n3.remove();		repoter.removeNewspaperOffice(n2);		repoter.getNewNews("another news coming!");	}}

Global Times got news coming!XinHua Daily got news coming!People Daily got news coming!Global Times got another news coming!

总结一下：

我们再来看看观察者模式：

当然具体实现方式上可以有多种变化

设计二，将记者和报社的合约关系独立出去，单独维护（封装），此时记者类不但与具体报社类解耦，甚至与报社抽象类解耦：

public abstract class Repoter {	protected String msg;	protected Relation relation;		public abstract void getNewNews(String msg);}

public class SpecificRepoter extends Repoter {	public SpecificRepoter(Relation relation){		this.relation = relation;	}		public void getNewNews(String msg){		this.msg = msg;		relation.notifyNewspaperOffice(msg);	}}

public interface Relation {	public void registerNewspaperOffice(NewspaperOffice no);	public void removeNewspaperOffice(NewspaperOffice no);	public void notifyNewspaperOffice(String msg);}

public class SpecificRelation implements Relation {	private List
    
      relation;		public SpecificRelation(){		relation = new ArrayList
     
      ();	}	public void registerNewspaperOffice(NewspaperOffice no) {		if(!relation.contains(no)){			relation.add(no);		}	}	public void removeNewspaperOffice(NewspaperOffice no) {		if(relation.contains(no)){			relation.remove(no);		}	}	public void notifyNewspaperOffice(String msg) {		if(null != relation && relation.size()>0){			for(NewspaperOffice no : relation){				no.update(msg);			}		}	}}
     
    

public abstract class NewspaperOffice {	protected Relation relation;	protected String newMsg;		public void register(){		relation.registerNewspaperOffice(this);	}		public void remove(){		relation.removeNewspaperOffice(this);	}		public abstract void update(String newMsg);}

public class PeopleDaily extends NewspaperOffice{	public PeopleDaily(Relation relation){		this.relation = relation;	}		public void update(String newMsg) {		this.newMsg = newMsg;		System.out.println("People Daily got "+newMsg);	}}