Java设计模式

通过组合多个命令形成宏命令(Macro Command).

通过通过记录命令历史信息,来实现命令的撤销功能.

优缺点

优点

1. 降低系统的耦合度,请求者和接收者不存在直接引用,两者之间具有良好的独立性.
2. 可以方便的增加新命令到系统中,无须修改原有代码,符合开闭原则.
3. 可以方便的设计宏命令,为请求的撤销和恢复提供了设计和实现方案.

缺点

1. 使用命令模式可能会导致系统有过多的具体命令类,因为每个对请求接收者的调用操作都需要一个具体命令类.

适用环境

1. 系统需要将请求调用者和请求接收者解耦,使得调用者和接收者不直接交互.
2. 系统需要在不同的时间指定请求,将请求排队和执行请求,命令对象和请求的初始调用者有不同的生命周期.
3. 系统需要支持命令的撤销(Undo)操作和恢复(Redo)操作.
4. 系统需要将一组操作组合在一起形成宏命令.

解释器模式

解释器模式用于描述如何使用面向对象语言构成一个简单的语言解释器.在某些情况下,为了更好地描述某些特定类型的问题可以创建一种新的语言,这种语言拥有自己的表达式和结构(文法规则),这些问题的实例将对应为该语言中的句子,此时可以使用解释器模式来设计这种新的语言.

以表达式为例说明文法规则和抽象语法树, 表达式为: 1+5-4

可以使用下面的文法规则来说明上诉表达式:

expression ::= value | operation
operation ::= expression '+' expression | expression '-' expression
value ::= an integer

第一条表示表达式的组成方式,value和operation是后面两个语言单位的定义,每一条语句所定义的字符串称为语言构造成分或语言单位,符合 ::= 是定义为的意思.语言单位有终结符表达式(value)和非终结符表达式(operation).

在文法规则定义中可以使用一些符号来表示不同的含义, 比如使用 | 表示或, 使用 { } 表示组合, 使用 * 表示出现0次或多次.

抽象语法树: 将终结符表达式和非终结符表达式通过一种树形结构组合起来.

结构

抽象表达式(AbstractExpression): 声明了抽象的解释操作,是所有终结符表达式和非终结符表达式的公共父类.

终结符表达式(TerminalExpression): 实现了抽象表达式的解释操作,每一个终结符是该类的一个实例.

非终结符表达式(NonterminalExpression): 实现了抽象表达式的解释操作,其中可包含终结符表达式,也可包含非终结符表达式.解释操作一般使用递归的方式完成.

环境类(Context): 又称上下文类,存储解释器之外的一些全局信息,临时存储了需要解释的语句.

应用实例

某公司开发一套机器人控制程序,其中包含一些简单的英文控制指令,每一个指令对应一个表达式,表达式可以是简单表达式,也可以是复合表达式,每一个简单表达式由移动方向,移动方式和移动距离3部分组成.移动方向有上下左右,移动方式有移动和快速移动,移动距离为一个正整数.两个表达式直接可以通过与(and)连接形成复合表达式.

/
 * 抽象节点类(抽象表达式)
 *
 * @author lzlg
 * 2023/3/5 11:25
 */
public abstract class AbstractNode {
    /
     * 解释语言文法
     *
     * @return 描述
     */
    public abstract String interpret();
}

/
 * 方向节点类(终结符表达式)
 *
 * @author lzlg
 * 2023/3/5 11:31
 */
public class DirectionNode extends AbstractNode {
    // 方向
    private final Direction direction;

    public DirectionNode(Direction direction) {
        this.direction = direction;
    }

    /
     * 解释语言文法
     *
     * @return 描述
     */
    @Override
    public String interpret() {
        return "向" + this.direction.desc;
    }

    enum Direction {
        UP("up", "上"), DOWN("down", "下"), LEFT("left", "左"), RIGHT("right", "右");

        private final String direct;

        private final String desc;

        Direction(String direct, String desc) {
            this.direct = direct;
            this.desc = desc;
        }

        /
         * 检查方向是否合法
         *
         * @param direct 方向
         * @return 结果
         */
        public static boolean check(String direct) {
            if (direct == null || "".equals(direct)) {
                return false;
            }
            Direction[] values = values();
            for (Direction value : values) {
                if (value.direct.equals(direct)) {
                    return true;
                }
            }
            return false;
        }

        /
         * 根据字符串返回方向
         *
         * @param direct 方向
         * @return 结果
         */
        public static Direction toDirection(String direct) {
            if (direct == null || "".equals(direct)) {
                throw new IllegalArgumentException("方向字符串为空");
            }
            Direction[] values = values();
            for (Direction value : values) {
                if (value.direct.equals(direct)) {
                    return value;
                }
            }
            throw new RuntimeException("无此方向");
        }
    }
}

/
 * 操作节点类(终结符表达式)
 *
 * @author lzlg
 * 2023/3/5 11:37
 */
public class ActionNode extends AbstractNode {
    // 操作
    private final Action action;

    public ActionNode(Action action) {
        this.action = action;
    }

    /
     * 解释语言文法
     *
     * @return 描述
     */
    @Override
    public String interpret() {
        return action.desc;
    }

    enum Action {
        MOVE("move", "移动"), RUN("run", "快速移动");

        private final String action;

        private final String desc;

        Action(String action, String desc) {
            this.action = action;
            this.desc = desc;
        }

        /
         * 检查操作是否合法
         *
         * @param action 操作
         * @return 结果
         */
        public static boolean check(String action) {
            if (action == null || "".equals(action)) {
                return false;
            }
            Action[] values = values();
            for (Action value : values) {
                if (value.action.equals(action)) {
                    return true;
                }
            }
            return false;
        }

        /
         * 根据字符串返回操作
         *
         * @param action 操作
         * @return 结果
         */
        public static Action toAction(String action) {
            if (action == null || "".equals(action)) {
                throw new IllegalArgumentException("操作字符串为空");
            }
            Action[] values = values();
            for (Action value : values) {
                if (value.action.equals(action)) {
                    return value;
                }
            }
            throw new RuntimeException("无此操作");
        }
    }
}

/
 * 距离节点(终结符表达式)
 *
 * @author lzlg
 * 2023/3/5 11:41
 */
public class DistanceNode extends AbstractNode {
    // 距离数字
    private final int distance;

    public DistanceNode(int distance) {
        if (distance < 0) {
            throw new IllegalArgumentException("移动距离不能小于0");
        }
        this.distance = distance;
    }

    /
     * 解释语言文法
     *
     * @return 描述
     */
    @Override
    public String interpret() {
        return String.valueOf(this.distance);
    }
}

/
 * 简单句子节点类(非终结符表达式)
 *
 * @author lzlg
 * 2023/3/5 11:29
 */
public class SentenceNode extends AbstractNode {
    // 方向
    private final AbstractNode direction;
    // 操作
    private final AbstractNode action;
    // 距离
    private final AbstractNode distance;

    public SentenceNode(AbstractNode direction, AbstractNode action, AbstractNode distance) {
        this.direction = direction;
        this.action = action;
        this.distance = distance;
    }

    /
     * 解释语言文法
     *
     * @return 描述
     */
    @Override
    public String interpret() {
        return this.direction.interpret() + this.action.interpret() + this.distance.interpret();
    }
}

/
 * And节点类(非终结符表达式)
 *
 * @author lzlg
 * 2023/3/5 11:27
 */
public class AndNode extends AbstractNode {

    public static final String AND = "and";
    // and的左表达式
    private final AbstractNode left;
    // and的右表达式
    private final AbstractNode right;

    public AndNode(AbstractNode left, AbstractNode right) {
        this.left = left;
        this.right = right;
    }

    /
     * 解释语言文法
     *
     * @return 描述
     */
    @Override
    public String interpret() {
        return this.left.interpret() + "再" + this.right.interpret();
    }
}

import java.util.Arrays;
import java.util.List;
import java.util.Stack;
import java.util.stream.Collectors;

/
 * 解释器
 *
 * @author lzlg
 * 2023/3/5 11:50
 */
public class InterpretHandler {
    /
     * 检查语句是否符合规范
     *
     * @param expression 语句
     * @return 结果
     */
    public boolean check(String expression) {
        if (expression == null || "".equals(expression)) {
            return false;
        }
        // 如果包含有and,则是多个表达式复合
        if (expression.contains(AndNode.AND)) {
            String[] expressions = expression.split(AndNode.AND);
            for (String exp : expressions) {
                // 如果有一个不合法,则直接返回false
                if (!this.checkSingleExpression(exp)) {
                    return false;
                }
            }
            return true;
        } else {
            return this.checkSingleExpression(expression);
        }
    }

    /
     * 检查单条语句是否合法
     *
     * @param expression 单条语句
     * @return 结果
     */
    private boolean checkSingleExpression(String expression) {
        if (expression == null || "".equals(expression)) {
            return false;
        }
        expression = expression.trim();
        String[] array = expression.split(" ");
        if (array.length != 3) {
            return false;
        }
        // 第一个是方向
        String direct = array[0];
        if (!DirectionNode.Direction.check(direct)) {
            return false;
        }
        // 第二个是操作
        String action = array[1];
        if (!ActionNode.Action.check(action)) {
            return false;
        }
        // 第三个是距离
        String distance = array[2];
        try {
            int dis = Integer.parseInt(distance);
            if (dis < 0) {
                return false;
            }
        } catch (NumberFormatException e) {
            System.out.println(e.getMessage());
            return false;
        }
        return true;
    }

    /
     * 解释语句为节点
     *
     * @param expression 语句
     * @return 节点
     */
    public AbstractNode interpret(String expression) {
        if (!this.check(expression)) {
            throw new IllegalArgumentException("语句不合法");
        }
        // 如果包含有and,则是多个表达式复合
        if (expression.contains(AndNode.AND)) {
            // 把语句分割为单条可解析的
            String[] array = expression.split(AndNode.AND);
            // 解析为语句节点列表
            List<SentenceNode> list = Arrays.stream(array).map(this::toSentenceNode)
                    .collect(Collectors.toList());
            // 使用栈来帮助生成最终的节点
            Stack<AbstractNode> stack = new Stack<>();
            for (SentenceNode node : list) {
                // 如果栈容量为空,则将当前节点入栈
                if (stack.isEmpty()) {
                    stack.push(node);
                } else {
                    // 弹出节点
                    AbstractNode left = stack.pop();
                    // 组合成and节点
                    AndNode andNode = new AndNode(left, node);
                    // 然后入栈
                    stack.push(andNode);
                }
            }
            return stack.pop();
        } else {
            return this.toSentenceNode(expression);
        }
    }

    /
     * 将单条语句转换为句子节点
     *
     * @param expression 语句
     * @return 句子节点
     */
    private SentenceNode toSentenceNode(String expression) {
        String exp = expression.trim();
        String[] array = exp.split(" ");
        DirectionNode direction = new DirectionNode(DirectionNode.Direction.toDirection(array[0]));
        ActionNode action = new ActionNode(ActionNode.Action.toAction(array[1]));
        DistanceNode distance = new DistanceNode(Integer.parseInt(array[2]));
        return new SentenceNode(direction, action, distance);
    }
}

/
 * 客户端类
 *
 * @author lzlg
 * 2023/3/5 15:16
 */
public class Client {
    public static void main(String[] args) {
        String andExpression = "up move 5 and down run 10 and left move 5";
        InterpretHandler handler = new InterpretHandler();
        AbstractNode node = handler.interpret(andExpression);
        System.out.println(node.interpret());
        System.out.println("=====================");
        String expression = "down run 10";
        node = handler.interpret(expression);
        System.out.println(node.interpret());
    }
}

/
 * 抽象迭代器接口
 *
 * @author lzlg
 * 2023/3/5 16:21
 */
public interface AbstractIterator<T> {
    /
     * 移至下一个元素
     */
    void next();

    /
     * 是否为最后一个元素
     *
     * @return 结果
     */
    boolean isLast();

    /
     * 移至上一个元素
     */
    void previous();

    /
     * 是否为第一个元素
     *
     * @return 结果
     */
    boolean isFirst();

    /
     * 获取下一个元素
     *
     * @return 元素
     */
    T nextItem();

    /
     * 获取上一个元素
     *
     * @return 元素
     */
    T prevItem();
}

/
 * 抽象聚合类
 *
 * @author lzlg
 * 2023/3/5 16:18
 */
public abstract class AbstractObjectList<T> {

    protected final List<T> objects;

    public AbstractObjectList(List<T> objects) {
        this.objects = objects;
    }

    public void addObject(T t) {
        this.objects.add(t);
    }

    public void removeObject(T t) {
        this.objects.remove(t);
    }

    public List<T> getObjects() {
        return this.objects;
    }

    /
     * 创建迭代器
     *
     * @return 迭代器
     */
    public abstract AbstractIterator<T> createIterator();
}

import java.math.BigDecimal;

/
 * 产品类
 *
 * @author lzlg
 * 2023/3/5 16:27
 */
public class Product {

    private String name;

    private BigDecimal amount;

    public Product(String name, BigDecimal amount) {
        this.name = name;
        this.amount = amount;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public BigDecimal getAmount() {
        return amount;
    }

    public void setAmount(BigDecimal amount) {
        this.amount = amount;
    }

    @Override
    public String toString() {
        return "[ 产品名称: " + name + ", 产品价格: " + amount + " ]";
    }
}

import java.util.List;

/
 * 产品迭代器类(具体迭代器)
 *
 * @author lzlg
 * 2023/3/5 16:29
 */
public class ProductIterator implements AbstractIterator<Product> {
    // 产品数据列表
    private final List<Product> list;
    // 正向遍历游标
    private int nextCursor;
    // 逆向遍历的游标
    private int prevCursor;

    public ProductIterator(ProductList list) {
        this.list = list.getObjects();
        this.nextCursor = 0;
        this.prevCursor = this.list.size() - 1;
    }

    /
     * 移至下一个元素
     */
    @Override
    public void next() {
        if (nextCursor < list.size()) {
            nextCursor++;
        }
    }

    /
     * 是否为最后一个元素
     *
     * @return 结果
     */
    @Override
    public boolean isLast() {
        return nextCursor == list.size();
    }

    /
     * 移至上一个元素
     */
    @Override
    public void previous() {
        if (prevCursor > -1) {
            prevCursor--;
        }
    }

    /
     * 是否为第一个元素
     *
     * @return 结果
     */
    @Override
    public boolean isFirst() {
        return prevCursor == -1;
    }

    /
     * 获取下一个元素
     *
     * @return 元素
     */
    @Override
    public Product nextItem() {
        return list.get(nextCursor);
    }

    /
     * 获取上一个元素
     *
     * @return 元素
     */
    @Override
    public Product prevItem() {
        return list.get(prevCursor);
    }
}

import java.util.List;

/
 * @author lzlg
 * 2023/3/5 16:25
 */
public class ProductList extends AbstractObjectList<Product> {
    public ProductList(List<Product> products) {
        super(products);
    }

    /
     * 创建迭代器
     *
     * @return 迭代器
     */
    @Override
    public AbstractIterator<Product> createIterator() {
        return new ProductIterator(this);
    }
}

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;

/
 * 客户端类
 *
 * @author lzlg
 * 2023/3/5 16:35
 */
public class Client {
    public static void main(String[] args) {
        List<Product> products = Arrays.asList(
                new Product("iPhone5s", new BigDecimal("1999.9")),
                new Product("iPhoneSE3", new BigDecimal("2999.9")),
                new Product("iPhone14ProMax", new BigDecimal("6999.9"))
        );

        AbstractObjectList<Product> list = new ProductList(products);
        AbstractIterator<Product> iterator = list.createIterator();
        System.out.println("正向遍历:");
        while (!iterator.isLast()) {
            System.out.print(iterator.nextItem() + "\t");
            iterator.next();
        }
        System.out.println("\n============================");
        System.out.println("逆向遍历:");
        while (!iterator.isFirst()) {
            System.out.print(iterator.prevItem() + "\t");
            iterator.previous();
        }
    }
}

/
 * 抽象同事类
 *
 * @author lzlg
 * 2023/3/5 17:04
 */
public abstract class Component {

    private Mediator mediator;

    public Component(Mediator mediator) {
        this.mediator = mediator;
    }

    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }

    public void changed() {
        if (this.mediator != null) {
            this.mediator.componentChanged(this);
        }
    }

    public abstract void update(String content);
}

/
 * 按钮(具体同事类)
 *
 * @author lzlg
 * 2023/3/5 17:11
 */
public class Button extends Component {

    public Button(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void update(String content) {
        // 不进行响应
    }

    public String getInput() {
        return "张无忌";
    }
}

/
 * 列表框(具体同事类)
 *
 * @author lzlg
 * 2023/3/5 17:12
 */
public class ListBox extends Component {

    public ListBox(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void update(String content) {
        System.out.println("列表框增加: " + content);
    }

    public String select() {
        return "周芷若";
    }

    public void show(String select) {
        System.out.println("列表框选中: " + select);
    }
}

/
 * 组合框(具体同事类)
 *
 * @author lzlg
 * 2023/3/5 17:12
 */
public class ComboBox extends Component {

    public ComboBox(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void update(String content) {
        System.out.println("组合框增加: " + content);
    }

    public String select() {
        return "杨不悔";
    }

    public void show(String content) {
        System.out.println("组合框选中: " + content);
    }
}

/
 * 文本框(具体同事类)
 *
 * @author lzlg
 * 2023/3/5 17:12
 */
public class TextBox extends Component {

    public TextBox(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void update(String content) {
        System.out.println("文本框增加: " + content);
    }

    public void setText(String text) {
        System.out.println("文本框显示: " + text);
    }
}

/
 * 抽象中介者
 *
 * @author lzlg
 * 2023/3/5 17:03
 */
public abstract class Mediator {

    public abstract void componentChanged(Component c);
}

/
 * 具体中介者
 *
 * @author lzlg
 * 2023/3/5 17:16
 */
public class ConcreteMediator extends Mediator {

    private Button button;

    private ListBox listBox;

    private ComboBox comboBox;

    private TextBox textBox;

    public void setComponents(Button button, ListBox listBox, ComboBox comboBox, TextBox textBox) {
        this.button = button;
        this.listBox = listBox;
        this.comboBox = comboBox;
        this.textBox = textBox;
    }

    @Override
    public void componentChanged(Component c) {
        if (c == button) {
            String input = button.getInput();
            System.out.println("=====单击增加按钮=====");
            listBox.update(input);
            comboBox.update(input);
            textBox.update(input);
            return;
        }
        if (c == listBox) {
            String select = listBox.select();
            System.out.println("=====从列表框选择客户=====");
            comboBox.show(select);
            textBox.setText(select);
            return;
        }
        if (c == comboBox) {
            String select = comboBox.select();
            System.out.println("=====从组合框选择客户=====");
            listBox.show(select);
            textBox.setText(select);
        }
    }
}

/
 * 客户端
 *
 * @author lzlg
 * 2023/3/5 17:29
 */
public class Client {
    public static void main(String[] args) {
        ConcreteMediator mediator = new ConcreteMediator();
        Button button = new Button(mediator);
        ListBox listBox = new ListBox(mediator);
        ComboBox comboBox = new ComboBox(mediator);
        TextBox textBox = new TextBox(mediator);
        mediator.setComponents(button, listBox, comboBox, textBox);

        button.changed();
        System.out.println("===========================");
        listBox.changed();
    }
}

/
 * 象棋棋子类(原发器)
 *
 * @author lzlg
 * 2023/3/7 17:42
 */
public class Chessman {

    private final String name;

    private int x;

    private int y;

    public Chessman(String name, int x, int y) {
        this.name = name;
        this.x = x;
        this.y = y;
    }

    public String getName() {
        return name;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    /
     * 保存状态
     *
     * @return 备忘录
     */
    public ChessmanMemento save() {
        return new ChessmanMemento(this);
    }

    /
     * 恢复状态
     *
     * @param memento 备忘录
     */
    public void restore(ChessmanMemento memento) {
        this.setX(memento.getX());
        this.setY(memento.getY());
    }

    @Override
    public String toString() {
        return "棋子: " + name + ", 当前位置为: 第" + x + "行,第" + y + "列.";
    }
}

/
 * 象棋棋子备忘录
 *
 * @author lzlg
 * 2023/3/7 17:44
 */
public class ChessmanMemento {

    private String name;

    private int x;

    private int y;

    public ChessmanMemento(Chessman chessman) {
        this(chessman.getName(), chessman.getX(), chessman.getY());
    }

    public ChessmanMemento(String name, int x, int y) {
        this.name = name;
        this.x = x;
        this.y = y;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}

/
 * 象棋棋子备忘录管理(负责人)
 *
 * @author lzlg
 * 2023/3/7 17:46
 */
public class MementoCaretaker {

    private ChessmanMemento memento;

    public ChessmanMemento getMemento() {
        return memento;
    }

    public void setMemento(ChessmanMemento memento) {
        this.memento = memento;
    }
}

/
 * 客户端类
 *
 * @author lzlg
 * 2023/3/7 17:48
 */
public class Client {
    public static void main(String[] args) {
        MementoCaretaker caretaker = new MementoCaretaker();

        Chessman chessman = new Chessman("车", 1, 1);
        System.out.println(chessman);
        // 保存当前状态
        caretaker.setMemento(chessman.save());
        System.out.println("走棋>>>>>>>>>");
        // 设置新位置
        chessman.setY(4);
        System.out.println(chessman);
        System.out.println("悔棋<<<<<<<<<");
        // 进行悔棋
        chessman.restore(caretaker.getMemento());
        System.out.println(chessman);
    }
}

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

/
 * 战队指挥中心(抽象目标类)
 *
 * @author lzlg
 * 2023/3/7 18:15
 */
public abstract class AllyControlCenter {

    protected final String allyName;

    protected final List<AllyObserver> players;

    public AllyControlCenter(String allyName) {
        this.allyName = allyName;
        this.players = new ArrayList<>();
    }

    public String getAllyName() {
        return allyName;
    }

    public void join(AllyObserver player) {
        System.out.println(player.getName() + "加入" + this.allyName + "战队.");
        this.players.add(player);
    }

    public void quit(AllyObserver player) {
        System.out.println(player.getName() + "退出" + this.allyName + "战队.");
        this.players.remove(player);
    }

    /
     * 通知队员遭受攻击
     *
     * @param name 被攻击队员名称
     */
    public abstract void notifyAttack(String name);
}

/
 * 具体战队指挥中心(具体目标类)
 *
 * @author lzlg
 * 2023/3/7 18:22
 */
public class ConcreteAllyControlCenter extends AllyControlCenter {

    public ConcreteAllyControlCenter(String allyName) {
        super(allyName);
    }

    @Override
    public void notifyAttack(String name) {
        System.out.println(this.allyName + "战队紧急通知,队友:" + name + "受到敌人攻击.");
        for (AllyObserver player : players) {
            if (player.getName().equals(name)) {
                continue;
            }
            player.help();
        }
    }
}

/
 * 战队观察者(观察者接口)
 *
 * @author lzlg
 * 2023/3/7 18:16
 */
public interface AllyObserver {
    /
     * 获取队友名称
     *
     * @return 队友名称
     */
    String getName();

    /
     * 帮助队友
     */
    void help();

    /
     * 通知自己遭受攻击
     *
     * @param controlCenter 指挥中心
     */
    void beAttacked(AllyControlCenter controlCenter);
}

/
 * 战队成员(具体观察者)
 *
 * @author lzlg
 * 2023/3/7 18:21
 */
public class AllyPlayer implements AllyObserver {
    // 玩家名称
    private final String name;

    public AllyPlayer(String name) {
        this.name = name;
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public void help() {
        System.out.println("坚持住," + this.name + "正在前来支援.");
    }

    @Override
    public void beAttacked(AllyControlCenter controlCenter) {
        System.out.println("战队:" + controlCenter.getAllyName() + "中的" + this.name + "受到攻击.");
        controlCenter.notifyAttack(this.name);
    }
}

/
 * 客户端
 *
 * @author lzlg
 * 2023/3/7 18:31
 */
public class Client {
    public static void main(String[] args) {
        AllyControlCenter controlCenter = new ConcreteAllyControlCenter("IKun");
        AllyObserver play1 = new AllyPlayer("菜坤");
        AllyObserver play2 = new AllyPlayer("王只因");
        AllyObserver play3 = new AllyPlayer("张太美");
        controlCenter.join(play1);
        controlCenter.join(play2);
        controlCenter.join(play3);
        System.out.println("=============================");
        play1.beAttacked(controlCenter);
    }
}

import java.math.BigDecimal;

/
 * 账户(环境类)
 *
 * @author lzlg
 * 2023/3/7 19:09
 */
public class Account {

    private final String owner;

    private BigDecimal balance;

    private AccountState state;

    public static final BigDecimal NEGATIVE_TWO_THOUSAND = new BigDecimal("-2000");

    public Account(String owner, BigDecimal balance) {
        this.owner = owner;
        this.balance = balance;
        this.state = new NormalState(this);
        this.state.stateCheck();
        System.out.println(owner + "开户,初始金额为:" + balance);
        System.out.println("-------------------------------------------");
    }

    public BigDecimal getBalance() {
        return balance;
    }

    public void setBalance(BigDecimal balance) {
        if (NEGATIVE_TWO_THOUSAND.compareTo(balance) <= 0) {
            this.balance = balance;
        } else {
            throw new RuntimeException("只能透支:" + NEGATIVE_TWO_THOUSAND.abs() + "元.");
        }
    }

    public void setState(AccountState state) {
        this.state = state;
    }

    /
     * 存款
     *
     * @param amount 金额
     */
    public void deposit(BigDecimal amount) {
        System.out.println(this.owner + "存款" + amount);
        System.out.println("存款前余额为:" + this.balance + ",账户状态为:" + this.state.getName());
        this.state.deposit(amount);
        System.out.println("存款后余额为:" + this.balance + ",账户状态为:" + this.state.getName());
        System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
    }

    /
     * 取款
     *
     * @param amount 金额
     */
    public void withdraw(BigDecimal amount) {
        System.out.println(this.owner + "取款" + amount);
        System.out.println("取款前余额为:" + this.balance + ",账户状态为:" + this.state.getName());
        this.state.withdraw(amount);
        System.out.println("取款后余额为:" + this.balance + ",账户状态为:" + this.state.getName());
        System.out.println("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
    }

    /
     * 计算利息
     */
    public void computeInterest() {
        this.state.computeInterest();
    }
}

import java.math.BigDecimal;

/
 * 账户状态(抽象状态类)
 *
 * @author lzlg
 * 2023/3/7 19:10
 */
public abstract class AccountState {

    private final String name;

    protected Account account;

    public AccountState(String name, Account account) {
        this.name = name;
        this.account = account;
    }

    public String getName() {
        return name;
    }

    /
     * 存款
     *
     * @param amount 金额
     */
    public abstract void deposit(BigDecimal amount);

    /
     * 取款
     *
     * @param amount 金额
     */
    public abstract void withdraw(BigDecimal amount);

    /
     * 计算利息
     */
    public abstract void computeInterest();

    /
     * 状态转换
     */
    public abstract void stateCheck();
}

import java.math.BigDecimal;

import static com.lzlg.study.design.state.Account.NEGATIVE_TWO_THOUSAND;

/
 * 正常状态(具体状态类)
 *
 * @author lzlg
 * 2023/3/7 19:12
 */
public class NormalState extends AccountState {
    public NormalState(Account account) {
        super("正常", account);
    }

    /
     * 存款
     *
     * @param amount 金额
     */
    @Override
    public void deposit(BigDecimal amount) {
        account.setBalance(account.getBalance().add(amount));
        this.stateCheck();
    }

    /
     * 取款
     *
     * @param amount 金额
     */
    @Override
    public void withdraw(BigDecimal amount) {
        account.setBalance(account.getBalance().subtract(amount));
        this.stateCheck();
    }

    /
     * 计算利息
     */
    @Override
    public void computeInterest() {
        System.out.println(this.getName() + "状态,无须支付利息.");
    }

    /
     * 状态转换
     */
    @Override
    public void stateCheck() {
        BigDecimal balance = account.getBalance();
        // 如果小于0且大于-2000则为透支状态
        if (balance.compareTo(NEGATIVE_TWO_THOUSAND) > 0 && balance.compareTo(BigDecimal.ZERO) <= 0) {
            account.setState(new OverdraftState(account));
        } else if (balance.compareTo(NEGATIVE_TWO_THOUSAND) == 0) {
            account.setState(new RestrictedState(account));
        }
    }
}

import java.math.BigDecimal;

import static com.lzlg.study.design.state.Account.NEGATIVE_TWO_THOUSAND;

/
 * 透支状态(具体状态类)
 *
 * @author lzlg
 * 2023/3/7 19:12
 */
public class OverdraftState extends AccountState {
    public OverdraftState(Account account) {
        super("透支", account);
    }

    /
     * 存款
     *
     * @param amount 金额
     */
    @Override
    public void deposit(BigDecimal amount) {
        account.setBalance(account.getBalance().add(amount));
        this.stateCheck();
    }

    /
     * 取款
     *
     * @param amount 金额
     */
    @Override
    public void withdraw(BigDecimal amount) {
        account.setBalance(account.getBalance().subtract(amount));
        this.stateCheck();
    }

    /
     * 计算利息
     */
    @Override
    public void computeInterest() {
        System.out.println("按天计算利息.利率为: 千分之6");
    }

    /
     * 状态转换
     */
    @Override
    public void stateCheck() {
        BigDecimal balance = account.getBalance();
        if (balance.compareTo(BigDecimal.ZERO) >= 0) {
            account.setState(new NormalState(account));
        } else if (balance.compareTo(NEGATIVE_TWO_THOUSAND) == 0) {
            account.setState(new RestrictedState(account));
        }
    }
}

import java.math.BigDecimal;

import static com.lzlg.study.design.state.Account.NEGATIVE_TWO_THOUSAND;

/
 * 受限状态(具体状态类)
 *
 * @author lzlg
 * 2023/3/7 19:12
 */
public class RestrictedState extends AccountState {
    public RestrictedState(Account account) {
        super("受限", account);
    }

    /
     * 存款
     *
     * @param amount 金额
     */
    @Override
    public void deposit(BigDecimal amount) {
        account.setBalance(account.getBalance().add(amount));
        this.stateCheck();
    }

    /
     * 取款
     *
     * @param amount 金额
     */
    @Override
    public void withdraw(BigDecimal amount) {
        account.setBalance(account.getBalance().subtract(amount));
        this.stateCheck();
    }

    /
     * 计算利息
     */
    @Override
    public void computeInterest() {
        System.out.println("按天计算利息.利率为: 千分之8");
    }

    /
     * 状态转换
     */
    @Override
    public void stateCheck() {
        BigDecimal balance = account.getBalance();
        if (balance.compareTo(BigDecimal.ZERO) >= 0) {
            account.setState(new NormalState(account));
        } else if (balance.compareTo(NEGATIVE_TWO_THOUSAND) > 0) {
            account.setState(new OverdraftState(account));
        }
    }
}

import java.math.BigDecimal;

/
 * 客户端
 *
 * @author lzlg
 * 2023/3/7 19:49
 */
public class Client {
    public static void main(String[] args) {
        Account account = new Account("小李", new BigDecimal("888"));
        account.withdraw(new BigDecimal("1888"));
        account.computeInterest();
        account.withdraw(new BigDecimal("1000"));
        account.computeInterest();
        account.deposit(new BigDecimal("5000"));
        account.computeInterest();
    }
}

import java.math.BigDecimal;

/
 * 电影票(环境类)
 *
 * @author lzlg
 * 2023/3/8 14:45
 */
public class MovieTicket {
    // 电影名称
    private final String movie;
    // 票价
    private final BigDecimal price;
    // 折扣
    private Discount discount;

    public MovieTicket(String movie, BigDecimal price) {
        this.movie = movie;
        this.price = price;
    }

    public String getMovie() {
        return movie;
    }

    /
     * 获取票价
     *
     * @return 票价
     */
    public BigDecimal getPrice() {
        if (discount == null) {
            return price;
        }
        return discount.calculate(this.price);
    }

    /
     * 设置折扣信息
     *
     * @param discount 折扣
     */
    public void setDiscount(Discount discount) {
        this.discount = discount;
    }

    @Override
    public String toString() {
        return "电影: " + movie + " 的票价为: " + this.getPrice() + "元.";
    }
}

import java.math.BigDecimal;

/
 * 折扣接口(抽象策略类)
 *
 * @author lzlg
 * 2023/3/8 14:45
 */
public interface Discount {
    /
     * 折扣计算
     *
     * @param price 票价
     * @return 折扣后票价
     */
    BigDecimal calculate(BigDecimal price);
}

import java.math.BigDecimal;

/
 * 学生折扣(具体策略类)
 *
 * @author lzlg
 * 2023/3/8 14:52
 */
public class StudentDiscount implements Discount {
    // 8折
    private static final BigDecimal TWENTY_OFF = new BigDecimal("0.8");

    /
     * 折扣计算
     *
     * @param price 票价
     * @return 折扣后票价
     */
    @Override
    public BigDecimal calculate(BigDecimal price) {
        System.out.println("学生票: ");
        return TWENTY_OFF.multiply(price);
    }
}

import java.math.BigDecimal;

/
 * 儿童折扣(具体策略类)
 *
 * @author lzlg
 * 2023/3/8 14:54
 */
public class ChildrenDiscount implements Discount {

    private static final BigDecimal DISCOUNT = new BigDecimal("10");

    private static final BigDecimal TWENTY_PRICE = new BigDecimal("20");

    /
     * 折扣计算
     *
     * @param price 票价
     * @return 折扣后票价
     */
    @Override
    public BigDecimal calculate(BigDecimal price) {
        System.out.println("儿童票: ");
        // 如果票价小于20元,则不进行优惠
        if (TWENTY_PRICE.compareTo(price) > 0) {
            return price;
        }
        // 否则优惠10元
        return price.subtract(DISCOUNT);
    }
}

import java.math.BigDecimal;

/
 * VIP用户折扣(具体策略类)
 *
 * @author lzlg
 * 2023/3/8 14:54
 */
public class VIPDiscount implements Discount {

    private static final BigDecimal DISCOUNT = new BigDecimal("0.5");

    /
     * 折扣计算
     *
     * @param price 票价
     * @return 折扣后票价
     */
    @Override
    public BigDecimal calculate(BigDecimal price) {
        System.out.println("VIP票: ");
        System.out.println("增加积分: " + price.intValue());
        // 优惠半价
        return price.multiply(DISCOUNT);
    }
}

import java.math.BigDecimal;

/
 * 客户端
 *
 * @author lzlg
 * 2023/3/8 15:02
 */
public class Client {
    public static void main(String[] args) {
        MovieTicket movieTicket = new MovieTicket("流浪地球2", new BigDecimal(32));
        System.out.println(movieTicket);
        System.out.println("============================");
        Discount discount = new StudentDiscount();
        movieTicket.setDiscount(discount);
        System.out.println(movieTicket);
        System.out.println("============================");
        discount = new ChildrenDiscount();
        movieTicket.setDiscount(discount);
        System.out.println(movieTicket);
        System.out.println("============================");
        discount = new VIPDiscount();
        movieTicket.setDiscount(discount);
        System.out.println(movieTicket);
    }
}

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

/
 * 账户类(抽象模板类)
 *
 * @author lzlg
 * 2023/3/8 15:31
 */
public abstract class Account {
    // 账户数据Map
    static final Map<String, String> accountMap;

    static {
        accountMap = new HashMap<>();
        accountMap.put("小李", "123000");
    }

    /
     * 计算利息(模板方法)
     *
     * @param account  账户名
     * @param password 账户密码
     */
    public void handle(String account, String password) {
        if (!this.validate(account, password)) {
            System.out.println("账户或密码错误.");
            return;
        }
        // 计算利息
        BigDecimal interest = this.calculateInterest();
        // 如果需要显示利息,则进行显示
        if (this.isShowInterest()) {
            // 显示利息
            this.displayInterest(interest);
        }
    }

    /
     * 验证账户(通用方法,不能让子类重写)
     *
     * @param account  账户
     * @param password 密码
     * @return 结果
     */
    public final boolean validate(String account, String password) {
        System.out.println("账户: " + account + ", 密码: " + password);
        // 从数据库中取账户信息
        String storePassword = accountMap.get(account);
        // 如果为空,则没有此账户
        if (Objects.isNull(storePassword)) {
            return false;
        }
        // 比对密码
        return storePassword.equals(password);
    }

    /
     * 计算利息(留给子类实现)
     *
     * @return 利息
     */
    public abstract BigDecimal calculateInterest();

    /
     * 是否显示利息(钩子方法,子类可通过钩子方法控制显示利息)
     *
     * @return 结果
     */
    public boolean isShowInterest() {
        return true;
    }

    /
     * 显示利息(子类可覆盖,自定义显示办法)
     *
     * @param interest 利息
     */
    public void displayInterest(BigDecimal interest) {
        System.out.println("利息为: " + interest);
    }
}

import java.math.BigDecimal;

/
 * 活期账户(具体模板类)
 *
 * @author lzlg
 * 2023/3/8 15:42
 */
public class CurrentAccount extends Account {
    /
     * 计算利息(留给子类实现)
     *
     * @return 利息
     */
    @Override
    public BigDecimal calculateInterest() {
        System.out.println("按活期计算利息: ");
        return new BigDecimal("2.33");
    }

    /
     * 不显示利息(钩子方法,子类可通过钩子方法控制显示利息)
     *
     * @return 结果
     */
    @Override
    public boolean isShowInterest() {
        return false;
    }
}

import java.math.BigDecimal;

/
 * 定期账户(具体模板类)
 *
 * @author lzlg
 * 2023/3/8 15:42
 */
public class SavingAccount extends Account {
    /
     * 计算利息(留给子类实现)
     *
     * @return 利息
     */
    @Override
    public BigDecimal calculateInterest() {
        System.out.println("按定期计算利息: ");
        return new BigDecimal("11.11");
    }

    /
     * 显示利息(子类可覆盖,自定义显示办法)
     *
     * @param interest 利息
     */
    @Override
    public void displayInterest(BigDecimal interest) {
        System.out.println("定期利息为: " + interest);
    }
}

/
 * 客户端
 *
 * @author lzlg
 * 2023/3/8 15:46
 */
public class Client {
    public static void main(String[] args) {
        Account account = new CurrentAccount();
        account.handle("小李", "123456");
        System.out.println("===========================");
        account.handle("小李", "123000");
        System.out.println("===========================");
        account = new SavingAccount();
        account.handle("小李", "123000");
    }
}

/
 * 员工类(抽象元素类)
 *
 * @author lzlg
 * 2023/3/8 16:20
 */
public interface Employee {
    /
     * 接受部门访问者的访问
     *
     * @param department 部门访问者
     */
    void accept(Department department);
}

import java.math.BigDecimal;
import java.util.Objects;

/
 * 抽象员工类
 *
 * @author lzlg
 * 2023/3/8 16:24
 */
public abstract class AbstractEmployee implements Employee {
    // 员工名称
    private final String name;
    // 员工工资(正式员工是周薪,临时工是时薪)
    private final BigDecimal wage;
    // 工作时长(单位小时)
    private final int workTime;

    public AbstractEmployee(String name, BigDecimal wage, int workTime) {
        Objects.requireNonNull(name);
        Objects.requireNonNull(wage);
        if (BigDecimal.ZERO.compareTo(wage) > 0) {
            throw new IllegalArgumentException("薪资不能为负数");
        }
        if (workTime < 0) {
            throw new IllegalArgumentException("工作时长不能为负数");
        }
        this.name = name;
        this.wage = wage;
        this.workTime = workTime;
    }

    public String getName() {
        return name;
    }

    public BigDecimal getWage() {
        return wage;
    }

    public int getWorkTime() {
        return workTime;
    }
}

import java.math.BigDecimal;

/
 * 正式员工(具体元素类)
 *
 * @author lzlg
 * 2023/3/8 16:22
 */
public class FullTimeEmployee extends AbstractEmployee {

    public FullTimeEmployee(String name, BigDecimal wage, int workTime) {
        super(name, wage, workTime);
    }

    /
     * 接受部门访问者的访问
     *
     * @param department 部门访问者
     */
    @Override
    public void accept(Department department) {
        department.visit(this);
    }
}

import java.math.BigDecimal;

/
 * 临时工(具体元素类)
 *
 * @author lzlg
 * 2023/3/8 16:22
 */
public class PartTimeEmployee extends AbstractEmployee {

    public PartTimeEmployee(String name, BigDecimal wage, int workTime) {
        super(name, wage, workTime);
    }

    /
     * 接受部门访问者的访问
     *
     * @param department 部门访问者
     */
    @Override
    public void accept(Department department) {
        department.visit(this);
    }
}

/
 * 部门类(抽象访问者)
 *
 * @author lzlg
 * 2023/3/8 16:20
 */
public abstract class Department {
    /
     * 访问正式员工的方法
     *
     * @param employee 正式员工
     */
    public abstract void visit(FullTimeEmployee employee);

    /
     * 访问临时工的方法
     *
     * @param employee 临时工
     */
    public abstract void visit(PartTimeEmployee employee);
}

import java.math.BigDecimal;

/
 * 财务部门(具体访问者)
 *
 * @author lzlg
 * 2023/3/8 16:31
 */
public class FinanceDepartment extends Department {
    /
     * 访问正式员工的方法
     *
     * @param employee 正式员工
     */
    @Override
    public void visit(FullTimeEmployee employee) {
        // 工作时长
        int workTime = employee.getWorkTime();
        // 周薪
        BigDecimal wage = employee.getWage();
        // 最终工资
        BigDecimal finalWage = wage;
        // 如果工作时间大于40小时
        if (workTime > 40) {
            // 超出40小时的部分乘以100加上原周薪
            finalWage = wage.add(new BigDecimal(100 * (workTime - 40)));
            // 如果工作时间小于40小时
        } else if (workTime < 40) {
            // 原周薪减去未满工时(40 - workTime)乘以80
            finalWage = wage.subtract(new BigDecimal((40 - workTime) * 80));
            // 如果计算出的薪资比零小,则工资直接为0
            if (finalWage.compareTo(BigDecimal.ZERO) < 0) {
                finalWage = BigDecimal.ZERO;
            }
        }
        System.out.println("正式员工: " + employee.getName() + ", 本周实际工资为: " + finalWage + "元.");
    }

    /
     * 访问临时工的方法
     *
     * @param employee 临时工
     */
    @Override
    public void visit(PartTimeEmployee employee) {
        // 工作时长
        int workTime = employee.getWorkTime();
        // 时薪
        BigDecimal wage = employee.getWage();
        // 最终工资=时薪乘以工作时长
        BigDecimal finalWage = wage.multiply(new BigDecimal(workTime));
        System.out.println("临时工: " + employee.getName() + ", 本周实际工资为: " + finalWage + "元.");
    }
}

/
 * 人力资源部门(具体访问者)
 *
 * @author lzlg
 * 2023/3/8 16:31
 */
public class HRDepartment extends Department {
    /
     * 访问正式员工的方法
     *
     * @param employee 正式员工
     */
    @Override
    public void visit(FullTimeEmployee employee) {
        int workTime = employee.getWorkTime();
        System.out.println("正式员工: " + employee.getName() + ", 本周工作时间: " + workTime + "小时.");
        if (workTime > 40) {
            System.out.println("正式员工: " + employee.getName() + ", 本周加班时间: " + (workTime - 40) + "小时.");
        } else if (workTime < 40) {
            System.out.println("正式员工: " + employee.getName() + ", 本周请假时间: " + (40 - workTime) + "小时.");
        }
    }

    /
     * 访问临时工的方法
     *
     * @param employee 临时工
     */
    @Override
    public void visit(PartTimeEmployee employee) {
        System.out.println("临时工: " + employee.getName() + ", 本周工作时间: " + employee.getWorkTime() + "小时.");
    }
}

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;

/
 * 客户端
 *
 * @author lzlg
 * 2023/3/8 16:49
 */
public class Client {
    public static void main(String[] args) {
        List<Employee> employees = Arrays.asList(
                new FullTimeEmployee("小李", new BigDecimal(5000), 48),
                new FullTimeEmployee("小张", new BigDecimal(4000), 40),
                new FullTimeEmployee("小王", new BigDecimal(2500), 35),
                new PartTimeEmployee("小菜", new BigDecimal(100), 60),
                new PartTimeEmployee("小鸡", new BigDecimal(200), 22)
        );
        System.out.println("财务部统计员工工资: ");
        Department department = new FinanceDepartment();
        for (Employee employee : employees) {
            employee.accept(department);
        }
        System.out.println("=============================");
        System.out.println("人力资源部统计员工工作时长: ");
        department = new HRDepartment();
        for (Employee employee : employees) {
            employee.accept(department);
        }

    }
}