Java设计模式

1. 解释器模式设计。
   解释器模式比较难懂，这里我能利用一个案例来说明解释器模式。
   比如写一个算术运算的案例，用来做数据的运算。
   例:输入 一加一 输出二
   输入 一加三减一 输出三
   输入 一加一加三减四 输出一
2. 下面用代码来实现这个功能

这里首先需要写一个接口，所有的数字，和运算符都要实现这个接口

public interface Expression{
      //这里需要一个抽象方法，用来返回运算出的数值
      public int intercept();//这里需要返回一个值
}

写一个数值类用来实现上面的接口。这个类我们用来返回一个单独的值。

public class Number implements Expression{
         //这里有一个属性是用来表示数值的
         private int number;
         //利用分支语句
         public Number(char word){
                  switch(word){
                          case '零':
                          number = 0;
                          break;
                          case '一':
                          number = 1;
                          break;
                          case '二':
                          number = 2;                          
                          break;
                          case '三':
                          number = 3; 
                          break;
                          case '四':
                          number = 4;                           
                          break;
                          case '五':
                          number = 5;                                                  
                          break;
                          case '六':
                          number = 6;                                                                            
                          break;
                          case '七':
                          number = 7;                                                                                                      
                          break;
                          case '八':
                          number = 8;                                                                                                                                
                          break;
                          case '九':
                          number = 9;                                                                                                                                                          
                          break;
                  }
                  public int intercept(){
                           return number;
                  }
         }
}

在这里写一个抽象类我来做加减算术运算的规则

public abstract class Operate implements Expression{
          //这里需要聚合两个Expression
          private Expression left;
          private Expression right;
         //这里需要写一个构造方法
         public Operate(Expression left,Expression right){
                  this.left = left;
                  this.right = right;
         }
}

这里需要写一个做加法运算的类，继承自Operate

public class Adds extends Operate{
       public Adds(Expression left,Expression right){
               super(left,right);
               //这里重写接口中的intercept
               public int intercept(){
                      return left.intercept()+right.intercept();
               }
       }
}

写一个用来做减法运算的类

public class Jian extends Operate{
       public Jian(Expression left,Expression right){                       
                 super(left,right);               
       //这里重写接口中的intercept              
                   public int intercept(){                            
                          return left.intercept()-right.intercept();               
                   }       
         }
}

最后写一个类用来做用户输入的数值进行计算，这里需要用到Stack这个数据结构

public class Calcu{
        //这里需要写一个方法用来做运算
        public int culcu(String number){
        //这里的参数是一个字符串，就是输入一个运算公式，
                 //这里写一个栈
                 Stack<Expression> stack =new Stack<>();
                 for(int i = 0;i<number.length;i++){
                          chat  c = number.charAt(i);
                          //这里是将字符串的某个元素转换成字符
                          switch(c){
                                  case '加':
                                  stack.push(new adds(stack.pop(),number.charAt());
                          }
                 }
                 
                 
        }
}