Java设计模式--行为者模式(二)

(7)观察者模式

概念：

一个对象的状态改变时，所有依赖于它的对象都得到通知并被自动更新

代码实现：

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

public class BinaryObserver extends Observer {
​
    public BinaryObserver(Subject subject) {
        this.subject=subject;
        this.subject.attach(this);
    }
​
    @Override
    public void update() {
        System.out.println("binary:"+Integer.toBinaryString(subject.getState()));
    }
}

public class OctalObserver extends Observer {
    public OctalObserver(Subject subject){
        this.subject = subject;
        this.subject.attach(this);
    }
​
    @Override
    public void update() {
        System.out.println( "Octal String: "
                + Integer.toOctalString( subject.getState() ) );
    }
}

package com.study.shejiPattern.observer;
​
import java.util.ArrayList;
import java.util.List;
​
public class Subject {
    private List<Observer> observers=new ArrayList<>();
    private int state;
​
    public int getState() {
        return state;
    }
​
    public void setState(int state) {
        this.state = state;
        notifyAllObservers();
    }
​
    public void attach(Observer observer){
        observers.add(observer);
    }
    public void notifyAllObservers(){
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

package com.study.shejiPattern.observer;
​
public class Client {
    public static void main(String[] args) {
        Subject subject=new Subject();
        new BinaryObserver(subject);
        new OctalObserver(subject);
        System.out.println("first 16");
        subject.setState(16);
        System.out.println("second 20");
        subject.setState(20);
    }
}

(8)状态模式

概念：

类的行为是基于状态改变，允许对象在内部状态发生改变时改变它的行为。

根据状态改变行为，看起来像是对象变了，实际上只是状态改变导致行为变了，对象还是没变

 

代码实现：

public interface State {
    void doAction(Context context);
}

public class StartAction implements State {
    @Override
    public void doAction(Context context) {
        System.out.println("start");
        context.setState(this);
    }
​
    public String toString(){
        return "start state";
    }
}

public class StopAction implements State {
    @Override
    public void doAction(Context context) {
        System.out.println("stop");
        context.setState(this);
    }
​
    public String toString(){
        return "stop state";
    }
}

public class Context {
    private State state;
​
    public Context() {
        state=null;
    }
​
    public State getState() {
        return state;
    }
​
    public void setState(State state) {
        this.state = state;
    }
}

public class Client {
    public static void main(String[] args) {
        Context context=new Context();
        StartAction startAction=new StartAction();
        StopAction stopAction=new StopAction();
        startAction.doAction(context);
        System.out.println(context.getState().toString());
        stopAction.doAction(context);
        System.out.println(context.getState().toString());
    }
}

(9)策略模式

概念：

一个类的行为或其算法可以在运行时更改

代码实现：

跟状态模式类似，只是这里是一个操作，而状态模式是一个状态

(10)模板模式

概念：

一段操作的流程是一样的，不同在于操作不同，比如一个游戏，都是开始、玩、结束，但是不同的游戏就有不同的开始、玩、结束。

主要是在抽象类中定义方法，子类可以重写方法达到自定义的效果，但是调用用抽象类中的方法进行调用

代码实现：

public abstract class Game {
   abstract void initialize();
   abstract void startPlay();
   abstract void endPlay();
 
   //模板
   public final void play(){
 
      //初始化游戏
      initialize();
 
      //开始游戏
      startPlay();
 
      //结束游戏
      endPlay();
   }
}

public class Cricket extends Game {
 
   @Override
   void endPlay() {
      System.out.println("Cricket Game Finished!");
   }
 
   @Override
   void initialize() {
      System.out.println("Cricket Game Initialized! Start playing.");
   }
 
   @Override
   void startPlay() {
      System.out.println("Cricket Game Started. Enjoy the game!");
   }
}

public class Football extends Game {
 
   @Override
   void endPlay() {
      System.out.println("Football Game Finished!");
   }
 
   @Override
   void initialize() {
      System.out.println("Football Game Initialized! Start playing.");
   }
 
   @Override
   void startPlay() {
      System.out.println("Football Game Started. Enjoy the game!");
   }
}

public class TemplatePatternDemo {
   public static void main(String[] args) {
 
      Game game = new Cricket();
      game.play();
      System.out.println();
      game = new Football();
      game.play();      
   }
}

(11)访问者模式

概念：

将数据操作与数据结构分离，主要是在被访问的类中提供一个对外访问的接口