20145328 《Java程序设计》实验二实验报告

20145328 《Java程序设计》实验二实验报告

实验名称

Java面向对象程序设计

实验内容

1. 初步掌握单元测试和TDD
2. 理解并掌握面向对象三要素：封装、继承、多态
3. 初步掌握UML建模
4. 熟悉S.O.L.I.D原则
5. 了解设计模式

实验步骤

（一）单元测试

用程序解决问题时，要会写三种码：

1. 先按要求写出伪代码。
2. 然后写出产品代码。
3. 最后进行测试。

伪代码如下

百分制转五分制：
   如果成绩小于60，转成“不及格”
   如果成绩在60与70之间，转成“及格”
   如果成绩在70与80之间，转成“中等”
   如果成绩在80与90之间，转成“良好”
   如果成绩在90与100之间，转成“优秀”
   其他，转成“错误”

完成的产品代码如下

public class MyUtil{
   public static String percentage2fivegrade(int grade){
       //如果成绩小于60，转成“不及格”
       if (grade < 60)
           return "不及格";
       //如果成绩在60与70之间，转成“及格”
       else if (grade < 70)
           return "及格";
       //如果成绩在70与80之间，转成“中等”
       else if (grade < 80)
           return "中等";
       //如果成绩在80与90之间，转成“良好”
       else if (grade < 90)
           return "良好";
       //如果成绩在90与100之间，转成“优秀”
       else if (grade < 100)
           return "优秀";
       //其他，转成“错误”
       else
           return "错误";
   }
}

新建一个测试类，代码如下所示

测试结果如下

测试正常情况的代码和运行结果如下所示

测试出错情况的代码和运行结果如下所示

在这里发现输入值为负时出现错误，修改原代码后测试运行便如下所示通过了

测试边界情况时也发现在当输入值为100时出现错误，修改原代码前后的测试运行结果如下所示

(二) TDD(Test Driven Devlopment, 测试驱动开发)

先根据需求写测试代码，然后再根据测试写产品代码，使产品代码通过测试。

1. 先创建一个test文件夹，修改其属性用来存放测试代码。
2. 在src中新建.java文件，用来编写产品代码。
3. 创建产品代码中的测试类，并存放到测试文件夹text中。

1. 根据需求编写测试代码。

试验测试代码：

public class MyUtility {
    public static String percentage2fivegrade(int grade) {
            return "错误";
    }
}

输入测试代码：

package experiment_2.TDD;

import experiment_2.TDD.MyUtility;
import junit.framework.TestCase;
import org.junit.Test;

/**
 * Created by Administrator on 2016/4/12.
 */
public class MyUtilityTest extends TestCase {
    @Test
    public void testNormal(){
        assertEquals("不及格", MyUtility.percentage2fivegrade(55));
        assertEquals("及格", MyUtility.percentage2fivegrade(65));
        assertEquals("中等", MyUtility.percentage2fivegrade(75));
        assertEquals("良好", MyUtility.percentage2fivegrade(85));
        assertEquals("优秀", MyUtility.percentage2fivegrade(95));
    }
    @Test
    public void testException(){
        assertEquals("错误",MyUtility.percentage2fivegrade(105));
        assertEquals("错误",MyUtility.percentage2fivegrade(-55));
    }
    @Test
    public void testBoundary(){
        assertEquals("不及格",MyUtility.percentage2fivegrade(0));
        assertEquals("及格",MyUtility.percentage2fivegrade(60));
        assertEquals("中等",MyUtility.percentage2fivegrade(70));
        assertEquals("良好",MyUtility.percentage2fivegrade(80));
        assertEquals("优秀",MyUtility.percentage2fivegrade(90));
        assertEquals("优秀",MyUtility.percentage2fivegrade(100));
    }
}

5.因为没有产品代码，测试代码存在错误，接下来，输入产品代码。

此时，测试代码运行成功

（三）用UML中的类图来描述类

该项实验于在实验楼上完成

（四）练习

使用TDD的方式设计关实现复数类Complex。

根据需求先写出伪代码

    //ComplexNumber的属性
    //m_dRealPart 实部
    //m_dImaginaryPart 虚部
    //ComplexNumber的方法
    //ComplexNumber() 构造函数，将实部，虚部都置为0
    //ComplexNumber(double r,double i) 构造函数，创建复数对象的同时完成复数的实部、虚部
    //GetRealPart() 获取实部
    //GetImaginaryPart() 获取虚部
    //SetRealPart(double d) 设置实部
    //SetImaginaryPart(double d) 设置虚部
    //ComplexAdd(ComplexNumber c) 复数相加
    //ComplexAdd(double c) 复数相加
    //ComplexMinus(ComplexNumber c) 复数相减
    //ComplexMinus(double c) 复数相减
    //ComplexMulti(ComplexNumber c) 复数相乘
    //ComplexMulti(double c) 复数相乘
    //toString()把当前复数对象的实部，虚部组合成a+bi的字符串形式

先写出预期测试代码，代码如下所示

package experiment_2.Complex;

import junit.framework.TestCase;
import org.junit.Test;

import static org.junit.Assert.*;

/**
 * Created by Administrator on 2016/4/14.
 */
public class ComplexTest extends TestCase {
    @Test
    public void testAdd(){
        Complex testa = new Complex(1, 2);
        Complex testb = new Complex(3, 5);
        Complex testc;
        testc = testa.Add(testb);
        assertEquals("4.0+7.0i",testc.toString());
    }
    @Test
    public void testMinus(){
        Complex testa = new Complex(1, 2);
        Complex testb = new Complex(6, 5);
        Complex testc;
        testc = testa.Minus(testb);
        assertEquals("-5.0-3.0i",testc.toString());
    }
    @Test
    public void testMulti(){
        Complex testa = new Complex(1, 2);
        Complex testb = new Complex(4, 8);
        Complex testc;
        testc = testa.Multi(testb);
        assertEquals("-12.0+16.0i",testc.toString());
    }
}

然后根据测试代码和伪代码写出产品代码，产品代码如下所示

package experiment_2.Complex;

/**
 * Created by Administrator on 2016/4/14.
 */
public class Complex {
    //ComplexNumber的属性
    private double m_dRealPart;//m_dRealPart 实部
    private double m_dImaginaryPart;//m_dImaginaryPart 虚部
    public Complex(double m_dRealPart,double m_dImaginaryPart){
        this.m_dRealPart = m_dRealPart;
        this.m_dImaginaryPart = m_dImaginaryPart;
    }

    //ComplexNumber的方法
    public void Complex(){//ComplexNumber() 构造函数，将实部，虚部都置为0
        this.m_dRealPart = 0;
        this.m_dImaginaryPart = 0;
    }
    public void Complex(double r,double i){//ComplexNumber(double r,double i) 构造函数，创建复数对象的同时完成复数的实部、虚部的初始化
        this.m_dRealPart = r;
        this.m_dImaginaryPart = i;
    }
    public double GetRealPart(){//GetRealPart() 获取实部
        return this.m_dRealPart;
    }
    public double GetImaginaryPart(){//GetImaginaryPart() 获取虚部
        return this.m_dImaginaryPart;
    }
    public void SetRealPart(double d){//SetRealPart(double d) 设置实部
        this.m_dRealPart = d;
    }
    public void SetImaginaryPart(double d){//SetImaginaryPart(double d) 设置虚部
        this.m_dImaginaryPart = d;
    }
    public Complex Add(Complex c){//ComplexAdd(ComplexNumber c) 复数相加
        return new Complex(m_dRealPart+c.m_dRealPart,m_dImaginaryPart+c.m_dImaginaryPart);
    }
    //ComplexAdd(double c) 复数相加
    public Complex Minus(Complex c){//ComplexMinus(ComplexNumber c) 复数相减
        return new Complex(m_dRealPart-c.m_dRealPart,m_dImaginaryPart-c.m_dImaginaryPart);
    }
    //ComplexMinus(double c) 复数相减
    public Complex Multi(Complex c){//ComplexMulti(ComplexNumber c) 复数相乘
        return new Complex(m_dRealPart*c.m_dRealPart-m_dImaginaryPart*c.m_dImaginaryPart,
                m_dRealPart*c.m_dImaginaryPart+m_dImaginaryPart*c.m_dRealPart);
    }
    //ComplexMulti(double c) 复数相乘
    public String toString(){//toString()把当前复数对象的实部，虚部组合成a+bi的字符串形式
        String s;
        if (m_dRealPart != 0.0){
            if (m_dImaginaryPart > 0)
                s = new Float(m_dRealPart).toString() + "+" + new Float(m_dImaginaryPart).toString() + "i";
            else if (m_dImaginaryPart < 0)
                s = new Float(m_dRealPart).toString() + "-" + new Float(-1*m_dImaginaryPart).toString() + "i";
            else
                s = new Float(m_dRealPart).toString();
        }
        else {
            if (m_dImaginaryPart > 0)
                s = new Float(m_dImaginaryPart).toString() + "i";
            else if (m_dImaginaryPart< 0)
                s = new Float(-1*m_dImaginaryPart).toString() + "i";
            else
                s = new Float(m_dRealPart).toString();
        }
        return s;
    }
    public void putout(Complex c){
        System.out.printf("%s%n",toString());
    }
}

产品代码运行结果如下

单元测试运行结果如下

心得体会

本次实验作为第二次实验，难度依旧适中，无论是单元测试还是利用UML建模，虽然原来没有接触过，感觉很新奇，但在接触过后也发现并没有预期中的那么困难，这两者从某些方面来说都算是在Java开发过程中的一种应用，更多的也是一种思想思路还有开发方法上的拓展，在练习通过TDD实现Complex类时不仅加深了对于TDD的了解，也逐渐掌握了TDD的应用，编写代码时的效率也比以前要快得多。

PSP(Personal Software Process)时间：

步骤	耗时	百分比
需求分析	20min	11.1%
设计	20min	11.1%
代码实现	1h	33.3%
测试	1h	33.3%
分析总结	20min	11.2%