面向对象编程思想-解释器模式

Posted 2020-10-06 快跑啊兔兔

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了面向对象编程思想-解释器模式相关的知识，希望对你有一定的参考价值。

一、引言

我们常常在会在字符串中搜索匹配字符或判断一个字符串是否符合我们要的格式时，使用正则表达式，可解决问题的背后是一种什么思想呢？即我们今天要学习的内容，解释器模式

二、解释器模式

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

1.文法：即语法规则。在解释器模式中每一个语法都对应一个解释器对象，用来处理相应的语法规则。它对于扩展、改变文法规则都很方便

2.可以通过抽象语法树（Abstract Syntax Tree，AST）的图形方式来直观的表示语言的构成，每一棵抽象语法树对应一个语言实例

下面是解释器模式的结构图

下面是代码demo：

     abstract class Expression
    {
        public void Interpret(PlayContext context)
        {
            if(context.PlayText.Length==0)
            {
                return;
            }
            else
            {
                string playKey = context.PlayText.Substring(0, 1);
                context.PlayText = context.PlayText.Substring(2);
                double playValue = Convert.ToDouble(context.PlayText.Substring(0, context.PlayText.IndexOf(" ")));
                context.PlayText = context.PlayText.Substring(context.PlayText.IndexOf(" ")+1);
                Excute(playKey, playValue);
            }
        }
        public abstract void Excute(string key,double value);
    }
     class Note : Expression
    {
        public override void Excute(string key, double value)
        {
            string note = "";
            switch (key)
            {
                case "C":
                    note = "1";
                    break;
                case "D":
                    note = "2";
                    break;
                case "E":
                    note = "3";
                    break;
                case "F":
                    note = "4";
                    break;
                case "G":
                    note = "5";
                    break;
                case "A":
                    note = "6";
                    break;
                case "B":
                    note = "7";
                    break;
            }
            Console.Write(note);
        }
    }
    class Scale : Expression
    {
        public override void Excute(string key, double value)
        {
            string scale = "";
            switch (Convert.ToInt32(value))
            {
                case 1:
                    scale = "低音";
                    break;
                case 2:
                    scale = "中音";
                    break;
                case 3:
                    scale = "高音";
                    break;
            }
            Console.Write(scale);
        }
    }
    //演奏内容
    class PlayContext
    {
        //演奏文本
        private string text;
        public string PlayText
        {
            get { return text; }
            set { text = value; }
        }
    }
     class Program
    {
        static void Main(string[] args)
        {
            PlayContext playContext = new PlayContext();
            Console.WriteLine("上海滩");
            playContext.PlayText = "O 1 E 2 C 0.5 D 2 A 5 G 0.5 P 2 P 0.5 O 2 E 2 O 3 C 0.5 E 2 C 1 ";
            Expression expression = null;
            try
            {
                while (playContext.PlayText.Length>0)
                {
                    string str = playContext.PlayText.Substring(0, 1);
                    switch (str)
                    {
                        case "O":
                            expression = new Scale();
                            break;
                        case "C":
                        case "D":
                        case "E":
                        case "F":
                        case "G":
                        case "A":
                        case "B":
                        case "P":
                            expression = new Note();
                            break;
                    }
                    expression.Interpret(playContext);
                }
            }
            catch (Exception ex )
            {
                Console.WriteLine(ex.Message);
            }
            Console.Read();
        }
    }

View Code

代码demo2：

    class ChineseEnglishDict
    {
        private static Dictionary<string, string> _dictionary = new Dictionary<string, string>();
        static ChineseEnglishDict()
        {
            _dictionary.Add("this", "这");
            _dictionary.Add("is", "是");
            _dictionary.Add("an", "一个");
            _dictionary.Add("apple", "苹果");
        }
        public static string GetEnglish(string value)
        {
            return _dictionary[value];
        }
    }
    //定义AbstractExpression接口
    interface IExpression
    {
        void Interpret(StringBuilder sb);
    }
    //定义具体的Expression，这里包括对英文单词的翻译和英文句号的翻译
    class WordExpression : IExpression
    {
        private string _value;
        public WordExpression(string value)
        {
            this._value = value;
        }
        public void Interpret(StringBuilder sb)
        {
            sb.Append(ChineseEnglishDict.GetEnglish(_value.ToLower()));
        }
    }
     //对英文句号的翻译
    class SymbolExpression : IExpression
    {
        private string _value;
        public SymbolExpression(string value)
        {
            this._value = value;
        }
        public void Interpret(StringBuilder sb)
        {
            switch (_value)
            {
                case ".":
                    sb.Append("。");
                    break;
            }
        }
    }
    //将解释器组合起来包装，方便外部调用
    public static class Translator
    {
        public static string Translate(string sentense)
        {
            StringBuilder sb = new StringBuilder();
            IList<IExpression> expressions = new List<IExpression>();
            string[] elements = sentense.Split(new char[] { \'.\' }, StringSplitOptions.RemoveEmptyEntries);
            foreach (string element in elements)
            {
                string[] words = element.Split(new char[] { \' \' }, StringSplitOptions.RemoveEmptyEntries);
                foreach (string word in words)
                {
                    expressions.Add(new WordExpression(word));
                }
                expressions.Add(new SymbolExpression("."));
            }
            foreach (IExpression expression in expressions)
            {
                expression.Interpret(sb);
            }
            return sb.ToString();
        }
    }
     class Program
    {
        static void Main(string[] args)
        {
            string english = "This is an Apple";
            string chinese = Translator.Translate(english);
            Console.WriteLine(chinese);
            Console.Read();
        }
    }