设计模式之行为型模式

 1、观察者模式：

/**
 * 抽象观察目标
 */
public abstract class Subject {
    protected ArrayList<Observer> observers=new ArrayList<>();//定义一个观察者集合用于存储所有观察对象
    //注册方法，用于向观察者集合中添加一个观察者
    public void attach(Observer observer){
        observers.add(observer);
    }
    //注销方法，用于在观察者集合中删除一个观察者
    public void detach(Observer observer){
        observers.remove(observer);
    }
    //抽象通知方法
    public abstract void notifyObserver();
}

/**
 * 具体观察目标
 */
public class ConcreteSubject extends Subject {
    //通知所有观察者
    @Override
    public void notifyObserver(){
        for(Object obs:observers){
            ((Observer)obs).update();
        }
    }
}

/**
 * 抽象观察者
 */
public interface Observer {
    void update();//得到通知后的响应方法
}

/**
 * 具体观察者类
 */
public class ConcreteObserver implements Observer {
    ////得到通知后的响应方法
    @Override
    public void update() {
        System.out.println("ConcreteObserver update");
    }

    //当观察者变化时，调用观察目标类的通知方法
    public void change(ConcreteSubject concreteSubject){
        System.out.println("自身发生变化");
        concreteSubject.notifyObserver();//调用观察目标类的通知方法，以通知其他观察者
    }
}

public class Test {
    public static void main(String[] args){
        ConcreteObserver observer1=new ConcreteObserver();
        ConcreteObserver observer2=new ConcreteObserver();
        ConcreteSubject concreteSubject=new ConcreteSubject();
        concreteSubject.attach(observer1);
        concreteSubject.attach(observer2);

        observer1.change(concreteSubject);
    }
}

2、模板方法模式：

父类定义基本的方法，其中有一些是公共方法，而某些方法没有实现，而是由其子类去实现

public class AbstractClass {
    //子类的公有方法
    public void m1(){
        System.out.println("m1");
    }
    //需要子类去实现
    protected void m2(){
    }
}

public class ConcreteClass extends AbstractClass{
    public void m2(){
        System.out.println("m2");
    }
}

3、策略模式

在策略模式中，定义一些独立的类封装不同的算法。

Context类是一个环境类，是使用算法的类，环境类中维持一个对抽象类策略的实例，用以定义所采用的策略。UML类图如下：

代码如下：

public abstract class Strategy {
    public abstract void algorithm();
}

public class ConcreteStrategyA extends Strategy {
    @Override
    public void algorithm() {
        System.out.println("StrategyA execute");
    }
}

public class ConcreteStrategyB extends Strategy {
    @Override
    public void algorithm() {
        System.out.println("StrategyB execute");
    }
}

public class Context {
    private Strategy strategy;

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public void algorithm() {
        strategy.algorithm();
    }
}

public class Test {
    public static void main(String[] args){
        Context context=new Context();
        context.setStrategy(new ConcreteStrategyA());
        context.algorithm();
    }
}