命令模式

定义：将一个请求封装成一个对象，从而让你使用不同的请求把客户端参数化，对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能

角色：

Receive接收者角色：该角色就是干活的角色，传递入命令中执行任务。

Command命令角色：需要执行的所有命令都在这里声明。

Invoker调用者角色：接收到命令，并执行命令。

    //通用Receiver类
    public abstract class Receiver {
         //抽象接收者，定义每个接收者都必须完成的业务
         public abstract void doSomething();
    }

    //具体的Receiver类
    public class ConcreteReciver1 extends Receiver{
         //每个接收者都必须处理一定的业务逻辑
         public void doSomething(){
         }
    }

    //抽象的Command类
    public abstract class Command {
         //每个命令类都必须有一个执行命令的方法
         public abstract void execute();
    }

    //具体的Command类
    public class ConcreteCommand1 extends Command {
         //对哪个Receiver类进行命令处理
         private Receiver receiver;
         //构造函数传递接收者
         public ConcreteCommand1(Receiver _receiver){
                 this.receiver = _receiver;
         }
         //必须实现一个命令
         public void execute() {
                 //业务处理
                 this.receiver.doSomething();
         }
    }

    //调用者Invoker类
    public class Invoker {
         private Command command;
         //受气包，接受命令
         public void setCommand(Command _command){
                 this.command = _command;
         }
         //执行命令
         public void action(){
                 this.command.execute();
         }
    }

    public class Client {
         public static void main(String[] args) {
                 //首先声明调用者Invoker
                 Invoker invoker = new Invoker();
                 //定义接收者
                 Receiver receiver = new ConcreteReciver1();
                 //定义一个发送给接收者的命令
                 Command command = new ConcreteCommand1(receiver);
                 //把命令交给调用者去执行
                 invoker.setCommand(command);
                 invoker.action();
         }
    }

解释器模式

解释器模式是一种按照规定语法进行解析的方案，在现在项目中使用较少。

定义：给定一门语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。

     //抽象算术运算解释器
    public interface Expression {
        int interpret();
    }

    //数字解释器
    public class NumberExpression implements Expression{
        private int value;

        public NumberExpression(int value) {
            this.value = value;
        }

        @Override
        public int interpret() {
            return value;
        }
    }

    //加法解释器
    public class AddExpression implements Expression{
        private Expression exp1;
        private Expression exp2;

        public AddExpression(Expression exp1, Expression exp2) {
            this.exp1 = exp1;
            this.exp2 = exp2;
        }

        @Override
        public int interpret() {
            return exp1.interpret() + exp2.interpret();
        }
    }

    //处理与解释器相关的一些业务
    public class Calculator {
        private Stack<Expression> stack;

        public Calculator(String express){
            stack = new Stack<>();
            String[] elements = express.split(" ");
            for (int i = 0; i < elements.length; i++){
                switch (elements[i].charAt(0)){
                    case '+':
                        Expression e1 = stack.pop();
                        Expression e2 = new NumberExpression(Integer.valueOf(elements[++i]));
                        stack.push(new AddExpression(e1, e2));
                        break;
                    default:
                        stack.push(new NumberExpression(Integer.valueOf(elements[i])));
                        break;
                }
            }
        }

        public int cal(){
            return stack.pop().interpret();
        }
    }

    //客户端类
    public class Client {
        public static void main(String [] args){
            Calculator calculator = new Calculator(" 78 + 87 + 10 + 1");
            System.out.print(calculator.cal());
        }
    }