導入Java . util . iterator；
導入Java . util . vector；
/**
*
* @作者Seastar
*/
觀察到的接口{
public void addObserver(觀察者o)；
public void remove Observer(Observer o)；
公共void update()；
}
界面觀察者{
public void take action()；
}
類別調用程序{
私人觀察員o；
Handler處理程序；
公共調用者(觀察者o) {
new Handler()；
this.o = o
}
私有類處理程序擴展線程{
公共處理程序(){
handler = this
}
@覆蓋
公共無效運行(){
o . take action()；
}
}
public boolean test same Observer(Observer o){
return o = = this.o
}
公共void invoke() {
handler . start()；
}
}
類ObservedObject實現Observed {
私有向量& ltInvoker & gtobserverList = new Vector & ltInvoker & gt();
public void addObserver(觀察者o) {
observer list . add(new Invoker(o))；
}
public void remove Observer(Observer o){
叠代器& ltInvoker & gtit = observer list . iterator()；
while (it.hasNext()) {
invoker I = it . next()；
if (i.TestSameObserver(o)) {
observer list . remove(I)；
打破；
}
}
}
公共void更新(){
for (Invoker i : observerList) {
I . invoke()；
}
}
}
Observer era類實現Observer {
公共無效操作(){
System.out.println("我是觀察者A，狀態變了，所以我要做點什麽")；
}
}
ObserverB類實現Observer {
公共無效操作(){
System.out.println("我是觀察者B，我被告知做某件事")；
}
}
類Observer RC實現Observer {
公共無效操作(){
System.out.println("我是觀察者C，我只是看看，什麽都不做")；
}
}
公共類Main {
/**
* @param args命令行參數
*/
公共靜態void main(String[] args) {
ObserverA a = new ObserverA()；
ObserverB b = new ObserverB()；
observer RC c = new observer RC()；
observed object oo = new observed object()；
oo . addobserver(a)；
oo . addobserver(b)；
oo . addobserver(c)；
for(int I = 0；我& lt5;++i) {
oo.addObserver(新觀察者(){
公共無效操作(){
System.out.println("我是山寨觀察員"+"誰敢攔我")；
}
});
}
//有時oo發生了變化，所以它調用update並通知所有觀察者
oo . update()；
}
}
觀察者模式的本質是註冊壹個觀察者來觀察隨時可能發生變化的物體，當物體發生變化時自動通知觀察者。
這在被觀察對象影響範圍較大，可能導致多個類的行為發生變化時非常有用，因為被觀察對象影響的類可以在不修改被觀察對象代碼的情況下添加。這種設計模式使得代碼易於管理和維護，並減少了出錯的可能性。
至於異步機制，其實就是個噱頭。可以通過觀察對象或觀察者本身來實現。這個程序實際上是通過在observer類上包裝壹層invoker類來實現異步機制的。