当前位置：首页 > news >正文

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

news 来源：原创 2024/4/28 13:52:10

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

实验名称

Java面向对象程序设计

实验内容

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

实验步骤

（一）单元测试

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

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

伪代码如下

百分制转五分制：
   如果成绩小于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, 测试驱动开发)

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

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

根据需求编写测试代码。

试验测试代码：

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的应用，编写代码时的效率也比以前要快得多。