行为型模式之解释器模式

Posted 2020-07-26

tags:

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

概述

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

定义

解释器模式(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();
        }
    }