java 观察者模式

观察者模式就是一对多的关系时使用，观察者多个，被观察者一个，该模式就是被观察者改变时，所有观察该对象的观察者全部改变

例子：

首先由一个被观察者类：

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

public class Power {
       private List<Observer> ob = new ArrayList<Observer>();

       private int flag ;

public int getFlag() {
return flag;
}

public void setFlag(int flag) {
this.flag = flag;
notifyAllObservers();
}
       
public void attach(Observer observer)
{
     ob.add(observer);
}

public void notifyAllObservers()
{
     for (Observer obser : ob) 
     {
        obser.update();
     }
 } 
}

然后写一个观察者抽象类：

public abstract class Observer {
      protected Power power;
      public abstract void update(); 
}

然后观察者1类：

public class entity_ob1 extends Observer{

public entity_ob1(Power power)
{
this.power = power;
this.power.attach(this);
}

@Override
public void update() {
System.out.println("ob1 更新  " + power.getFlag() );
}
}

然后观察者2类：

public class entity_ob2 extends Observer{

public entity_ob2(Power power)
{
this.power = power;
this.power.attach(this);
}

@Override
public void update() {
System.out.println("ob2 更新  "+power.getFlag() );
}
}

然后观察者3类：

public class entity_ob3 extends Observer{

public entity_ob3(Power power)
{
this.power = power;
this.power.attach(this);
}

@Override
public void update() {
System.out.println("ob3 更新  " +power.getFlag());
}
}

最后一个test类：

public class test {
      public static void main(String [] args)
      {
     Power p = new Power();
     
     new entity_ob1(p);
     new entity_ob2(p);
     new entity_ob3(p);
     
     System.out.println("第一次修改");
     p.setFlag(6);
     System.out.println("第二次修改");
     p.setFlag(8);
      }
}

输出结果：

第一次修改
ob1 更新  6
ob2 更新  6
ob3 更新  6
第二次修改
ob1 更新  8
ob2 更新  8
ob3 更新  8