行为型模式之解释器模式

概述

解释器模式是一种使用频率相对较低但学习难度较大的设计模式，它用于描述如何使用面向对象语言构成一个简单的语言解释器。在某些情况下，为了更好地描述某一些特定类型的问题，我们可以创建一种新的语言，这种语言拥有自己的表达式和结构，即文法规则，这些问题的实例将对应为该语言中的句子。此时，可以使用解释器模式来设计这种新的语言。对解释器模式的学习能够加深我们对面向对象思想的理解，并且掌握编程语言中文法规则的解释过程

定义

解释器模式(Interpreter Pattern)：定义一个语言的文法，并且建立一个解释器来解释该语言中的句子，这里的“语言”是指使用规定格式和语法的代码。解释器模式是一种类行为型模式。

实现

节点类

    public interface Node
    {
        /// <summary>
        /// 翻译方法
        /// </summary>
        /// <returns></returns>
        int Interpret();
    }

值节点【非终结符表达式】

    public class ValueNode : Node
    {
        private int value;

        public ValueNode(int value)
        {
            this.value = value;
        }

        public int Interpret()
        {
            return this.value;
        }
    }

符号节点【终结符表达式】

    public abstract class SymbolNode : Node
    {
        protected Node left;
        protected Node right;

        public SymbolNode(Node left, Node right)
        {
            this.left = left;
            this.right = right;
        }

        public abstract int Interpret();
    }

加法节点

    public class AddNode : SymbolNode
    {
        public AddNode(Node left, Node right) : base(left, right)
        {
        }

        public override int Interpret()
        {
            return base.left.Interpret() + base.right.Interpret();
        }
    }

减法

    public class SubNode : SymbolNode
    {
        public SubNode(Node left, Node right) : base(left, right)
        {
        }

        public override int Interpret()
        {
            return base.left.Interpret() - base.right.Interpret();
        }
    }

乘法

    public class MulNode : SymbolNode
    {
        public MulNode(Node left, Node right) : base(left, right)
        {
        }

        public override int Interpret()
        {
            return base.left.Interpret() * base.right.Interpret();
        }
    }

除法

    public class DivNode : SymbolNode
    {
        public DivNode(Node left, Node right) : base(left, right)
        {
        }

        public override int Interpret()
        {
            return base.left.Interpret() / base.right.Interpret();
        }
    }

计算处理类

    public class Calculator
    {
        private Node node;

        public void build(String statement)
        {
            Node leftNode, rightNode;
            char[] charArray = statement.ToCharArray();
            string[] statementArr = charArray.Select(p => p.ToString()).Where(p => !string.IsNullOrWhiteSpace(p)).ToArray();

            for (int i = 0; i < statementArr.Length; i++)
            {
                if (statementArr[i].Equals("*"))
                {
                    leftNode = node;
                    rightNode = new ValueNode(int.Parse(statementArr[++i]));
                    node = new MulNode(leftNode, rightNode);
                }
                else if (statementArr[i].Equals("/"))
                {
                    leftNode = node;
                    rightNode = new ValueNode(int.Parse(statementArr[++i]));
                    node = new DivNode(leftNode, rightNode);
                }
                else if (statementArr[i].Equals("%"))
                {
                    leftNode = node;
                    rightNode = new ValueNode(int.Parse(statementArr[++i]));
                    node = new ModNode(leftNode, rightNode);
                }
                else {
                    node = new ValueNode(int.Parse(statementArr[i]));
                }
            }
        }

        public int Compute()
        {
            return node.Interpret();
        }
    }

客户端

    class Program
    {
        static void Main(string[] args)
        {
            String statement = "3 * 2 * 4 / 6 % 5";

            Calculator calculator = new Calculator();

            calculator.build(statement);

            int result = calculator.Compute();

            Console.ReadLine();
        }
    }

总结

1、 可扩展性比较好，灵活。

2、 增加了新的解释表达式的方式。

3、 易于实现文法。

缺点

1、 执行效率比较低，可利用场景比较少。

2、 对于复杂的文法比较难维护。

五、 模式适用场景

1、可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。

2、一些重复出现的问题可以用一种简单的语言来进行表达。

3、文法较为简单。