面向對象編程思想-解釋器模式

一、引言

我們常常在會在字元串中搜索匹配字元或判斷一個字元串是否符合我們要的格式時，使用正則表達式，可解決問題的背後是一種什麼思想呢？即我們今天要學習的內容，解釋器模式

二、解釋器模式

定義：給定一個語言，定義它的文法的一種表示，並定義一個解釋器，這個解釋器使用該表示來解釋語言中的句子

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();
        }
    }

代碼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();
        }
    }

優點：

1.易於實現文法。一條語法規則用一個解釋器來解釋執行，解釋器只需要考慮這一條語法規則的實現就可以了

2.易於擴展新的語法。可以通過繼承等方式創建相應的解釋器對象

缺點：

1.執行效率低。解釋器模式中使用了大量的迴圈或遞歸調用

2.對於複雜文法難以維護。每一條規則至少需要定義一個類，如果一個語言包含太多的文法規則，類的過程會急劇增加，導致系統難以管理和維護

適用場景：

1.當一個語言需要解釋執行，並可以將語言中的句子表示為一個抽象的語法樹的時候

2.一些重覆出現的問題可以用一種簡單的語言表達

3.一個語言的文法較為簡單

4.當執行效率不是關鍵和主要關心的問題

參考：

大話設計模式；

http://www.cnblogs.com/5iedu/p/5595153.html