在王者荣耀角度下分析面向对象程序设计B中23种设计模式之解释器模式

荣仔_最靓的仔

发布于 2021-02-02 17:36:00

4230

发布于 2021-02-02 17:36:00

文章被收录于专栏：一些有趣的Python案例一些有趣的Python案例

· 解释器模式在王者荣耀中的应用

·

一、简述

在王者荣耀手游中，有局内语音转文字功能，玩家通过使用普通话在5秒的倒计时内进行简短而有效的语音输入，系统会自动将玩家说的话在极短时间内转换成文字内容，然后点击发送，玩家的文字聊天信息就发送出去，其他玩家就可以以文字读取方式了解你要传达的信息了。

在本实例中，我们通过实现局内语音转文字功能进而说明解释器模式的应用实例。具体而言，当我们在语音转文字过程中是需要解释执行的，这样我们可以将转文字中每一个字句表示为一个类。但是由于汉语结构、规则复杂，过多的字句组合使得我们很难维护所有的类，所以在这里我们只简单做5个字的语音转换来说明解释器模式的应用实例。对于这一问题，如果使用程序实现这一效果的话，定义的基本操作是将语音的值转换为汉语文字，比如，发音“zhong”就解释执行为“中”，发音“le”就解释执行为“了”……这样一来，当玩家通过语音说“zhong lu yi bo le”时，程序就解释执行输出“中路一波了”。

二、解释器模式（Interpreter Pattern）

解释器模式理解： 高度概括：给定一个语言，定义他的文法的一种表示并定义一个解释器，这个解释器使用该表是来解释语言中的句子。对于某些问题，我们可能希望用简单的语言来描述及希望用简单的语言来实现一些操作，比如使用简单语言，实现简单的翻译操作，解释模式是关于怎样实现一个简单语言的陈述模式，其关键是将每一个语法规则表示成一个类。

解释器模式结构中的四种角色： ①抽象表达式（AbstractExpression）：该角色为一个接口，负责定义抽象的解释操作； ②终结符表达式（TerminalExpression）：实现抽象表达式接口的类，该类将接口中的解释操作实现为与文法中的终结符相关联的操作，即文法中每个终结符号需要一个终结符表达式类； ③非终结符表达式（NonterminalExpression）：实现抽象表达式接口的类，文法中的每一条规则都需要非终结符表达式类。非终结符表达式类为文法中的非终结符号实现解释操作，该解释操作通常使用递归调用表示对象的解释操作； ④上下文（Context）：包含解释器之外的一些全局信息。

解释器模式的UML类图：

解释器模式的优缺点： 优点： ①将每一个语法规则表示成一个类，方便实现简单的语言； ②由于使用肋表示语法规则可以较容易改变或扩展语言的行为； ③通过在类结构中加入新的方法，可以在解释的同时增加新的行为； 缺点： ①如果文法过于复杂，那么过多的文法规则是我们很难维护所给出的类； ②执行效率较低。

解释器模式的适用情景： 当有一个简单的语言需要解释执行，并且可以将该语言的每一个规则表示为一个类时，就可以使用解释器模式。

三、王者荣耀角度下实现解释器模式结构图及代码

eclipse结构图

主函数【应用（Application）】 Applicayion.java

public class Application{
     public static void main(String args[]){
    	  System.out.println("①当玩家使用“普通话”向队友发送消息时：");
    	  System.out.println("       【系统提示】正在打开麦克风……");
    	  System.out.println("       【系统提示】语音录入中……");
    	  System.out.println("       【系统提示】正在转换……");
    	  System.out.print("       【系统提示】转换成功：");
          String text="Zhong Lu Yi Bo Le";         
          Context context=new Context(text);
          Node node=new OneTwoNode();
          node.parse(context);
          node.execute();
          System.out.println("");
          System.out.println("");
          System.out.println("★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★");
          System.out.println("");
          System.out.println("②当玩家使用“方言”向队友发送消息时：");
          System.out.println("       【系统提示】正在打开麦克风……");
    	  System.out.println("       【系统提示】语音录入中……");
    	  System.out.println("       【系统提示】正在转换……");
    	  System.out.print("       【系统提示】转换成功：");
          text="Ji He Jin Gong Zhu Zai";         
          context=new Context(text);
          node=new OneTwoNode();
          node.parse(context);
          node.execute();
     }
}

抽象表达式（AbstractExpression） Node.java

public interface Node{
      public void parse(Context text);
      public void execute();
}

终结符表达式（TerminalExpression） OneNode.java

public class OneNode implements Node{
      String [] word={"Zhong","","","",""};
      String token; 
      boolean boo;
      public void parse(Context context){
             token=context.nextToken();
             int i=0;
             for(i=0;i<word.length;i++){
                if(token.equalsIgnoreCase(word[i])){
                    boo=true;
                    break;
                }
             }
             if(i==word.length)
                boo=false;
      }
      public void execute(){
            if(boo){
                if(token.equalsIgnoreCase(word[0]))
                   System.out.print("中"); 
            }       
     }
}

TwoNode.java

public class TwoNode implements Node{
      String [] word={"Lu","","","",""};
      String token; 
      boolean boo;
      public void parse(Context context){
             token=context.nextToken();
             int i=0;
             for(i=0;i<word.length;i++){
                if(token.equalsIgnoreCase(word[i])){
                    boo=true;
                    break;
                }
             }
             if(i==word.length)
                boo=false;
      }
      public void execute(){
            if(boo){
                if(token.equalsIgnoreCase(word[0]))
                    System.out.print("路"); 
            }    
     }
}

ThreeNode.java

public class TwoNode implements Node{
      String [] word={"Lu","","","",""};
      String token; 
      boolean boo;
      public void parse(Context context){
             token=context.nextToken();
             int i=0;
             for(i=0;i<word.length;i++){
                if(token.equalsIgnoreCase(word[i])){
                    boo=true;
                    break;
                }
             }
             if(i==word.length)
                boo=false;
      }
      public void execute(){
            if(boo){
                if(token.equalsIgnoreCase(word[0]))
                    System.out.print("路"); 
            }    
     }
}

ForeNode.java

public class ForeNode implements Node{
      String [] word={"","","","Bo",""};
      String token; 
      boolean boo;
      public void parse(Context context){
             token=context.nextToken();
             int i=0;
             for(i=0;i<word.length;i++){
                if(token.equalsIgnoreCase(word[i])){
                    boo=true;
                    break;
                }
             }
             if(i==word.length)
                boo=false;
      }
      public void execute(){
            if(boo){
                if(token.equalsIgnoreCase(word[3]))
                   System.out.print("波"); 
            }      
     }
}

FiveNode.java

public class FiveNode implements Node{
      String [] word={"","","","","Le"};
      String token; 
      boolean boo;
      public void parse(Context context){
             token=context.nextToken();
             int i=0;
             for(i=0;i<word.length;i++){
                if(token.equalsIgnoreCase(word[i])){
                    boo=true;
                    break;
                }
             }
             if(i==word.length)
                boo=false;
      }
      public void execute(){
            if(boo){
                if(token.equalsIgnoreCase(word[4]))
                   System.out.print("了"); 
            }
            else{
                System.out.print("呜呜呜~~~什么都没听清┭┮﹏┭┮");
            }        
     }
}

非终结符表达式（NonterminalExpression） FirstNode.java

public class FirstNode implements Node{
      Node node;
      public void parse(Context context){
            node =new OneNode();
            node.parse(context);
     }
      public void execute(){
           node.execute();
     }
}

TwiceNode.java

public class TwiceNode implements Node{
      Node node;
      public void parse(Context context){
            node =new TwoNode();
            node.parse(context);
     }
      public void execute(){
           node.execute();
     }
}

ThirdNode.java

public class ThirdNode implements Node{
      Node node;
      public void parse(Context context){
            node =new ThreeNode();
            node.parse(context);
     }
      public void execute(){
           node.execute();
     }
}

ForthNode.java

public class ForthNode implements Node{
      Node node;
      public void parse(Context context){
            node =new ForeNode();
            node.parse(context);
     }
      public void execute(){
           node.execute();
     }
}

FifthNode.java

public class FifthNode implements Node{
      Node node;
      public void parse(Context context){
            node =new FiveNode();
            node.parse(context);
     }
      public void execute(){
           node.execute();
     }
}

OneTwoNode.java

public class OneTwoNode implements Node{
      Node one,twoThree;
      public void parse(Context context){
            one =new FirstNode();
            twoThree=new TwoThreeNode();
            one.parse(context);
            twoThree.parse(context);
      }
      public void execute(){
           one.execute();
           twoThree.execute();
     }
}

TwoThreeNode.java

public class TwoThreeNode implements Node{
      Node two,threeFore;
      public void parse(Context context){
    	    two =new TwiceNode();
    	    threeFore=new ThreeForeNode();
            two.parse(context);
            threeFore.parse(context);
      }
      public void execute(){
    	  two.execute();
    	  threeFore.execute();
     }
}

ThreeForeNode.java

public class ThreeForeNode implements Node{
      Node three,foreFive;
      public void parse(Context context){
    	    three =new ThirdNode();
    	    foreFive=new ForeFiveNode();
    	    three.parse(context);
    	    foreFive.parse(context);
      }
      public void execute(){
    	  three.execute();
    	  foreFive.execute();
     }
}

ForeFiveNode.java

public class ForeFiveNode implements Node{
      Node fore,five;
      public void parse(Context context){
    	    fore =new ForthNode();
    	    five=new FifthNode();
    	    fore.parse(context);
            five.parse(context);
      }
      public void execute(){
    	  fore.execute();
    	  five.execute();
     }
}

上下文（Context） Context.java

import java.util.StringTokenizer;
public class Context{
      StringTokenizer tokenizer;
      String token;
      public Context(String text){
           setContext(text);
     } 
     public void setContext(String text){
          tokenizer=new StringTokenizer(text);
     }
      String nextToken(){
            if(tokenizer.hasMoreTokens()){
                 token=tokenizer.nextToken(); 
           }
           else
                token="";
           return token;
      } 
}

运行结果截图