设计模式-策略模式和观察者模式

策略模式

诸葛亮有许多锦囊妙计，每个锦囊妙计都对应着不同的算法和策略，以便在他需要什么策略的时候随取随用。使用策略模式可以动态地让一个对象在许多行为中选择一种行为，避免使用多重条件判断。

step1：创建一个接口：motive

public interface motive {
  public void opt();
}

step2：创建几个接口实现类

public class add implements motive {
  @Override
  public void opt() {
    System.out.println("执行加法！");
  }
}

public class delete implements motive {
  @Override
  public void opt() {
    System.out.println("执行减法！");
  }
}

step3：让我们创建一个诸葛亮

public class zhugeliang {

  private motive motive;
  
  void zhugeliang(){}
  
  public void setMotive(motive motive){
    this.motive = motive;
  }
  public void opt(){
    motive.opt();
  }
}

step4：创建测试类test来查看当它改变策略 motive 时的行为变化

public class test {
  public static void main(String[] args) {
    zhugeliang zgl = new zhugeliang();
    zgl.setMotive(new add());
    zgl.opt();
    zgl.setMotive(new delete());
    zgl.opt();
  }
}

类图

输出

观察者模式

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。

step1：创建Subject接口和实现类

public interface iSubject {
  void register(Observer observer);
  void remove(Observer observer);
  void notify(String message);
}

public class Subject implements iSubject {
  
  private List<Observer> observers;
  
  Subject(){
    this.observers = new ArrayList<>();
  }
  
  @Override
  public void register(Observer observer) {
    observers.add(observer);
  }
  
  @Override
  public void remove(Observer observer) {
    observers.remove(observer);
  }
  
  @Override
  public void notify(String message) {
    for(Observer observer : observers){
      observer.update(message);
    }
  }
}

step2：创建抽象Observer类

public abstract class Observer {
  protected Subject subject;
  public abstract void update(String message);
}

step3：创建实体类

public class ConcreteObserver1 extends Observer {
  private Subject subject; 
  public ConcreteObserver1(Subject subject){
    this.subject = subject;
    this.subject.register(this);
  }
  @Override
  public void update(String message){
    System.out.println("更新信息1 "+message);
  }
}

public class ConcreteObserver2 extends Observer {
  private Subject subject;
  public ConcreteObserver2(Subject subject){
    this.subject = subject;
    this.subject.register(this);
  }
  @Override
  public void update(String message) {
    System.out.println("更新信息2 " + message);
  }
}

step4：创建测试类

public class ConcreteObserver2 extends Observer {
  private Subject subject;
  public ConcreteObserver2(Subject subject){
    this.subject = subject;
    this.subject.register(this);
  }
  @Override
  public void update(String message) {
    System.out.println("更新信息2 " + message);
  }
}

类图

输出

Java内置了观察者模式的api，实现观察者模式非常简单，
[1]创建被观察者类，它继承自java.util.Observable类；
[2]创建观察者类，它实现java.util.Observer接口；

对象	api	描述
被观察者	void addObserver(Observer o)	添加被观察者的观察者
被观察者	setChanged(); notifyObservers();	setChange()方法用来设置一个内部标志位注明数据发生了变化； notifyObservers()方法会去调用观察者对象列表中所有的Observer的update()方法，通知它们数据发生了变化。只有在setChange()被调用后，notifyObservers()才会去调用update()。
观察者	void update(Observable o, Object arg)	形参Object arg，对应一个由notifyObservers(Object arg);传递来的参数，当执行的是notifyObservers();时，arg为null。

step1：创建观察者

public class NumbServerable extends Observable {
  private int data = 0;
  int getData(){
    return data;
  }
  public void setData(int data){
    this.data = data;
    setChanged();
    notifyObservers();
  }
}

step2：创建被观察者

public class NumbServer2 implements Observer {
  public NumbServer2(NumbServerable numbServerable) {
    super();
    numbServerable.addObserver(this);//注册加入观察者
  }
  @Override
  public void update(Observable o, Object arg) {
    NumbServerable numbServerable = (NumbServerable)o;
    System.out.println("Data2 has changed to " +numbServerable.getData());
  }
}

public class NumbServer1 implements Observer {
  public NumbServer1(NumbServerable numbServerable) {
    super();
    numbServerable.addObserver(this);//注册加入观察者
  }
  @Override
  public void update(Observable o, Object arg) {
    NumbServerable numbServerable = (NumbServerable)o;
    System.out.println("Data1 has changed to " +numbServerable.getData());
  }
}

step3：测试

public class test {
  public static void main(String[] args) {
    NumbServerable sm = new NumbServerable();
    NumbServer1 a = new NumbServer1(sm);
    NumbServer2 b = new NumbServer2(sm);
    sm.setData(5);
    sm.deleteObserver(a);//注销观察者，以后被观察者有数据变化就不再通知这个已注销的观察者
    sm.setData(10);
  }
}

输出