任务06——封装与单元测试(Markdown版)

模块代码地址

• Core 模块代码地址

• 单元测试代码地址

两个地址是一样的，为了方便，所以把测试的代码很模块代码放在一起git了。

封装阶段

public class Core {
    public static StringBuffer Suffix(StringBuffer infix){
        Stack<Character> stack=new Stack <Character>();
        StringBuffer suffix=new StringBuffer();
        int i=0;
        char tempchar=infix.charAt(i++);
        char tempchar2=' ';
        try {
            while (tempchar!='='){
                switch (tempchar){
                    case '(':
                        stack.push(tempchar);
                        tempchar=infix.charAt(i++);
                        break;
                    case ')':
                        while (stack.peek()!='('){
                            tempchar2=stack.pop();
                            suffix.append(tempchar2);
                            suffix.append(' ');
                            if (stack.empty()) {
                                break;
                            }
                        }
                        if (!stack.empty()) {
                            stack.pop();
                        }
                        tempchar=infix.charAt(i++);
                        break;
                    case '+':
                    case '-':
                        while (!stack.empty()&&stack.peek()!='('){
                            tempchar2=stack.pop();
                            suffix.append(tempchar2);
                            suffix.append(' ');
                        }
                        stack.push(tempchar);
                        tempchar=infix.charAt(i++);
                        break;
                    case '×':
                    case '*':
                    case '/':
                    case '÷':
                        Character ch=new Character(' ');
                        if (!stack.empty()) {
                            while((ch=stack.peek()).equals('×')||(ch=stack.peek()).equals('÷'))
                            {
                                tempchar2=stack.pop();
                                suffix.append(tempchar2);
                                suffix.append(' ');
                                if (stack.empty()) {
                                    break;
                                }
                            }
                        }
                        stack.push(tempchar);
                        tempchar=infix.charAt(i++);
                        break;
                    case ' ':
                        tempchar=infix.charAt(i++);
                        break;
                    default:
                        while(tempchar<='9'&&tempchar>='0')
                        {
                            suffix.append(tempchar);
                            tempchar=infix.charAt(i++);
                        }
                        suffix.append(' ');
                        break;
                }
            }
            while(!stack.empty())
            {
                tempchar2=stack.pop();
                suffix.append(tempchar2);
                suffix.append(' ');
            }
            suffix.append('\0');
        } catch (Exception e) {
            e.printStackTrace();
        }
        return suffix;
    }
    //根据后缀表达式计算结果（小数格式的String类型）
    public static String Calculate(StringBuffer suffix){
        int i=0;
        char tempchar=suffix.charAt(i++);
        double []answer=new double[20];
        int top=0,d;
        String Answer= null;
        try {
            while (tempchar!='\0'){
                switch (tempchar){
                    case '+':
                        answer[top-1]=answer[top-1]+answer[top];
                        top--;
                        tempchar=suffix.charAt(i++);
                        break;
                    case '-':
                        answer[top-1]=answer[top-1]-answer[top];
                        top--;
                        tempchar=suffix.charAt(i++);
                        break;
                    case '*':
                    case '×':
                        answer[top-1]=answer[top-1]*answer[top];
                        top--;
                        tempchar=suffix.charAt(i++);
                        break;
                    case '/':
                    case '÷':
                        try {
                            if(answer[top]!=0)
                                answer[top-1]=answer[top-1]/answer[top];
                            else
                            {
                                System.out.println("\n\t除零错误!\n");
                                throw new InvalidExpression("无效的表达式");
                            }
                        } catch (InvalidExpression invalidExpression) {
                            invalidExpression.printStackTrace();
                            System.exit(0);
                        }
                        top--;
                        tempchar=suffix.charAt(i++);
                        break;
                    case ' ':
                        tempchar=suffix.charAt(i++);
                        break;
                    default:
                        d=0;
                        while(tempchar>='0'&&tempchar<='9')
                        {
                            d=10*d+tempchar-'0';//将数字字符转化为对应的数值
                            tempchar=suffix.charAt(i++);
                        }
                        top++;
                        answer[top]=d;
                        break;
                }
            }
            Answer = null;
            if (top!=1){
                throw new InvalidExpression("无效的表达式");
            }
            Double an=new Double(answer[top]);
            Answer = new String(an.toString());
        }catch (InvalidExpression invalidExpression) {
            invalidExpression.printStackTrace();
        }catch (Exception e) {
            e.printStackTrace();
        }
        return Answer;
    }
}

在封装的过程中遇到的困难，以及是如何解决的:

对于封装首先想到几天前学习的软件工程的知识，关于模块的分解、抽象，恰好与本次的任务吻合，可以理论用于实践。上图是我画的UML图，在尝试在学习中，算不上很规范，但能基本看懂大概的结构。

因为之前的代码基于结构化编程，运用函数思想，所以在本次封装过程中很好的将功能抽象出来，这次完成的虽然不是很完美，但后期可以通过老师的指导不断改进。

单元测试阶段

单元测试代码 此处粘贴单元测试代码（用一对 ``` 把代码括起来）

	@Before
	public void before() throws Exception {
	} 
	@After
	public void after() throws Exception {
	} 
	/**
	*
	* Method: Suffix(StringBuffer infix)
	*
	*/
	@Test
	public void testSuffix() throws Exception {
    	Core s=new Core();
    	s.Suffix(new StringBuffer("1+2+3="));
    	s.Suffix(new StringBuffer("1+2×3="));
    	s.Suffix(new StringBuffer("1+2÷3="));
    	s.Suffix(new StringBuffer("1÷2×3="));
    	s.Suffix(new StringBuffer("1÷+2×3="));
    	s.Suffix(new StringBuffer("1÷2*3="));
    	s.Suffix(new StringBuffer("1÷0×3="));
    	s.Suffix(new StringBuffer("1÷2×0="));
	} 
	/**
	*
	* Method: Calculate(StringBuffer suffix)
	*
	*/
	@Test
	public void testCalculate() throws Exception {
    	Core s=new Core();
    	s.Calculate(new StringBuffer("1 2 + 3 +"));
    	s.Calculate(new StringBuffer("1 + 2 + 3 +"));
    	s.Calculate(new StringBuffer("1 2 +"));
    	s.Calculate(new StringBuffer("1 2 × 3 +"));
    	s.Calculate(new StringBuffer("1+ + 2 × 3 +"));
	} 
	}

单元测试运行结果（截图，含测试是否全部通过，代码覆盖率等）

在编写单元测试代码过程中遇到的困难，以及是如何解决的

按照老师提供的教程，一开始看不懂，需要自己慢慢琢磨，Junit包，不知道是哪个，IDEA上找到有好多个，后来自己在网上找一个发现可以用。

下面提供它的下载网址。

链接：http://pan.baidu.com/s/1o84pWQQ 密码：1mda

别的大问题没有，关于对Core的测试，计算表达式都是自己按照规则生成的，不会出现不规则的情况，

所以对于测试情况的全面性没有更深一步进行。

感受（小结）

Junit很方便，测试的时候，不能以编程时的思维方式去看待问题，否则有些问题永远测试不出来。

需要打破常规的思路，不能认为自己的代码运行结果都是对的。