[设计模式]行为型设计模式

简介

行为型设计模式：关注对象之间的通信

代码

1. 命令模式

```java
package me.maxiaolong.designpattern;

/**
 * @author maxiaolong
 * created at 2020/7/5
 * 命令模式：将一个请求封装为对象，从而使我们可以用不同的请求对客户进行参数化。本质是对命令进行封装，将发出命令的责任和执行命令的责任分割
 */
public class CommandClient {
    public static void main(String[] args) {
        Receiver receiver = new Receiver();
        //将发出命令的职责和执行命令的职责分割
        Command command = new ConcreteCommand(receiver);
        Invoker invoker = new Invoker(command);
        invoker.call();
    }
}

class Receiver{
    public void action(){
        System.out.println("Receiver action");
    }
}

class Invoker{

    /**
     * 聚合方式，Command命令对命令执行者Receiver进行关联，将其方法封装为对象
     */
    private Command command;

    public Invoker(Command command) {
        this.command = command;
    }

    public Command getCommand() {
        return command;
    }

    public void setCommand(Command command) {
        this.command = command;
    }

    public void call(){
        this.command.execute();
    }
}

abstract class Command{
    public abstract void execute();
}

class ConcreteCommand extends Command{

    private Receiver receiver;

    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }

    public Receiver getReceiver() {
        return receiver;
    }

    public void setReceiver(Receiver receiver) {
        this.receiver = receiver;
    }

    @Override
    public void execute() {
        receiver.action();
    }
}
```

2. 迭代器模式

```java
package me.maxiaolong.designpattern;

/**
 * @author maxiaolong
 * created at 2020/7/5
 * 迭代器模式用于对一个聚合对象进行遍历。聚合对象只负责数据存储，遍历对象职责交由迭代器来完成。
 */
public class IteratorClient {
    public static void process(Aggregate aggregate){
        Iterator iterator = aggregate.createIterator();
        while(!iterator.isLast()){
            System.out.println(iterator.currentItem());
            iterator.next();
        }
    }

    public static void main(String[] args) {
        Aggregate aggregate = new ConcreteAggregate();
        process(aggregate);
    }
}

/**
 * 先定义高层接口
 */
interface Aggregate{
    Iterator createIterator();
}

interface Iterator{
    void first();
    void next();
    boolean isLast();
    Object currentItem();
}


/**
 * 主聚合类的主要职责依然是数据存储
 */
class ConcreteAggregate implements Aggregate{

    private Object[] objArr = {"0", "1", "2", "3", "4"};

    @Override
    public Iterator createIterator() {
        return new ConcreteIterator();
    }

    /**
     * 私有内部类：通过私有迭代器内部类控制访问流程
     */
    private class ConcreteIterator implements Iterator{

        private int currentIndex = 0;

        @Override
        public void first() {
            currentIndex = 0;
        }

        @Override
        public void next() {
            currentIndex++;
        }

        @Override
        public boolean isLast() {
            return currentIndex == objArr.length;
        }

        @Override
        public Object currentItem() {
            return objArr[currentIndex];
        }
    }
}
```

3. 观察者模式

```java
package me.maxiaolong.designpattern;

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

/**
 * @author maxiaolong
 * created at 2020/7/5
 * 观察者模式是一种经常使用的设计模式。在软件系统中对象并不是孤立存在的，一个对象行为的改变可能会导致一个或者多个其它与之存在依赖关系的
 * 定义一种一对多的依赖关系，使得每当一个对象的状态发生改变时，其他相关依赖对象皆得到通知并自动更新。
 * 又叫做：发布订阅模式，模型视图模式
 * 比如：红灯亮汽车停；绿灯亮汽车行
 * 被观察者（目标）维护观察者列表，一旦目标发生改变就通知观察者发生变化(主动通知)
 * 比如开发过程中，同一数据模型关联多张视图的情况，修改数据模型修改多张视图表示。（我自己认为核心业务逻辑改变致使观察者状态发生改变，硬编码在）
 */
public class ObserverClient {
    public static void main(String[] args) {
        Observer observer = new ConcreteObserver();
        /**
         * 目标类内部维持一个观察者集合
         */
        Subject1 subject1 = new ConcreteSubject1();
        subject1.attach(observer);
        subject1.notifyObservers();
    }
}

interface Observer{
    void update();
}

abstract class Subject1{
    private List<Observer> observerList= new ArrayList<>();

    /**
     * 添加观察者
     * @param observer
     */
    public abstract void attach(Observer observer);

    /**
     * 删除观察者
     * @param observer
     */
    public abstract void detach(Observer observer);

    public List<Observer> getObserverList() {
        return observerList;
    }

    public void notifyObservers(){
        for(Object observer: observerList){
            ((Observer)observer).update();
        }
    }
}

class ConcreteObserver implements Observer{

    @Override
    public void update() {
        System.out.println("被观察者发生修改");
    }
}

class ConcreteSubject1 extends Subject1{

    @Override
    public void attach(Observer observer) {
        getObserverList().add(observer);
    }

    @Override
    public void detach(Observer observer) {
        getObserverList().remove(observer);
    }
}
```