二十三种设计模式第二十一篇--解释器模式

解释器模式(Interpreter Pattern)是一种行为设计模式,它用于定义一种语言的语法结构和解释器,使得可以解释并执行特定的语法规则。该模式可以将复杂的语言表达式分解为更小的语法单元,并定义其解释过程。

解释器模式的核心组成部分包括:

抽象表达式(Abstract Expression):定义了解释器的接口,其中包含一个interpret()方法,负责解释语言表达式。

终结符表达式(Terminal Expression):实现了抽象表达式的接口,用于表示语言中的终结符,即不需要进一步解释的语法单位。

非终结符表达式(Nonterminal Expression):实现了抽象表达式的接口,用于表示语言中的非终结符,即需要进一步解释的语法单位。

上下文(Context):包含需要解释的语言表达式,以及保存解释器所需的上下文信息。

客户端(Client):创建并配置解释器,将需要解释的语言表达式传递给解释器进行解释执行。

使用解释器模式的优点包括:

  1. 易于扩展语言解释能力:通过添加新的终结符和非终结符表达式,可以扩展语言的语法规则和解释能力。
  2. 灵活的语言处理:可以将复杂的语法规则分解为简单的解释器组件,灵活地组合进行语言处理。
  3. 可维护性和可读性:通过对语言表达式的分解和解释过程的抽象,可以提高代码的可维护性和可读性。

二十三种设计模式第二十一篇--解释器模式_第1张图片

/**
 * 抽象表达式(Abstract Expression)角色:定义解释器的接口,约定解释器的解释操作,主要包含解释方法 interpret()。
 */
public interface Expression {
   /**
    * 解析context内容是否满足要求
    * @param context
    * @return
    */
   public boolean interpret(String context);
}
/**
 * 多个表达式的与关系
 * 非终结符
 */
public class AndExpression implements Expression {
    
   private Expression expr1 = null;
   private Expression expr2 = null;
 
   public AndExpression(Expression expr1, Expression expr2) { 
      this.expr1 = expr1;
      this.expr2 = expr2;
   }
 
   @Override
   public boolean interpret(String context) {      
      return expr1.interpret(context) && expr2.interpret(context);
   }
}
public class InterpreterPatternDemo {
 
   //规则:Robert 和 John 是男性
   public static Expression getMaleExpression(){
      Expression robert = new TerminalExpression("Robert");
      Expression john = new TerminalExpression("John");
      return new OrExpression(robert, john);    
   }
 
   //规则:Julie 是一个已婚的女性
   public static Expression getMarriedWomanExpression(){
      Expression julie = new TerminalExpression("Julie");
      Expression married = new TerminalExpression("Married");
      return new AndExpression(julie, married);    
   }
 
   public static void main(String[] args) {
      Expression isMale = getMaleExpression();
      Expression isMarriedWoman = getMarriedWomanExpression();
 
      System.out.println("John is male? " + isMale.interpret("John and mike is a friend"));
      System.out.println("Julie is a married women? " 
      + isMarriedWoman.interpret("Married Julie"));
   }
}
/**
 * 多个表达式的或关系
 */
public class OrExpression implements Expression {
    
   private Expression expr1 = null;
   private Expression expr2 = null;
 
   public OrExpression(Expression expr1, Expression expr2) { 
      this.expr1 = expr1;
      this.expr2 = expr2;
   }
 
   @Override
   public boolean interpret(String context) {      
      return expr1.interpret(context) || expr2.interpret(context);
   }
}
/**
 * 终结符
 */
public class TerminalExpression implements Expression {

   //表达式的要求:
   private String data;
 
   public TerminalExpression(String data){
      this.data = data; 
   }

   /**
    * 判断 文本context是否满足   data的要求.
    * @param context
    * @return
    */
   @Override
   public boolean interpret(String context) {
      if(context.contains(data)){
         return true;
      }
      return false;
   }
}

然而,解释器模式也有一些限制和适用场景:

对于复杂的语法规则,可能需要大量的解释器组件和规则的定义,增加了代码的复杂性。可能对性能造成影响:由于解释过程需要进行递归调用,可能对性能产生影响。

学历不行也罢,技不如人也罢,只要你保持一颗上进的心,往某一个方面钻研,时间久了,你会发现自己不知不觉在成长,这一路上的经历,都是你最宝贵的财富,最重要的是你需要不断进取,不要荒废时光,学无止境,但是你可以钻研某一方面,技不在多,在于精。

20230801
BY: 罗小黑

你可能感兴趣的:(#,设计模式,设计模式,解释器模式)