20155334 实验二 Java面向对象程序设计

实验二 Java面向对象程序设计

实验内容

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

实验要求

1. 完成实验、撰写实验报告，实验报告以博客方式发表在博客园，注意实验报告重点是运行结果，遇到的问题、解决办法以及分析。
2. 严禁抄袭，有该行为者实验成绩归零，并附加其他惩罚措施。
3. 请大家先在实验楼中的~/Code目录中用自己的学号建立一个目录，代码和UML图要放到这个目录中，截图中没有学号的会要求重做，然后跟着下面的步骤练习。

实验步骤

（一）单元测试

(1) 三种代码

• 伪代码
• 产品代码
• 测试代码

例如：

需求：我们要在一个MyUtil类中解决一个百分制成绩转成“优、良、中、及格、不及格”五级制成绩的功能。

• 伪代码：

百分制转五分制：
   如果成绩小于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 "错误";
   }
}

• 测试代码：

public class MyUtilTest {
    public static void main(String[] args) {
        //测试边界情况
        if(MyUtil.percentage2fivegrade(0) != "不及格")
            System.out.println("test failed 1!");
        else if(MyUtil.percentage2fivegrade(60) != "及格")
            System.out.println("test failed 2!");
        else if(MyUtil.percentage2fivegrade(70) != "中等")
            System.out.println("test failed 3!");
        else if(MyUtil.percentage2fivegrade(80) != "良好")
            System.out.println("test failed 4!");
        else if(MyUtil.percentage2fivegrade(90) != "优秀")
            System.out.println("test failed 5!");
        else if(MyUtil.percentage2fivegrade(100) != "优秀")
            System.out.println("test failed 6!");
        else 
            System.out.println("test passed!"); 
    }
}

(2) 测试驱动开发(TDD)

TDD的一般步骤如下：

• 明确当前要完成的功能，记录成一个测试列表
• 快速完成编写针对此功能的测试用例
• 测试代码编译不通过
• 编写产品代码
• 测试通过
• 对代码进行重构，并保证测试通过
• 循环完成所有功能的开发

TDD的编码节奏是：

• 增加测试代码，JUnit出现红条
• 修改产品代码
• JUnit出现绿条，任务完成

注意测试用例前一定要有注解@Test。

（二）面向对象三要素

（1）抽象：

抽象就是抽出事物的本质特征而暂时不考虑他们的细节。对于复杂系统问题人们借助分层次抽象的方法进行问题求解；在抽象的最高层，可以使用问题环境的语言，以概括的方式叙述问题的解。

（2）封装、继承与多态

• 面向对象的三要素包括：封装、继承、多态。
• 面向对象的思想涉及到软件开发的各个方面，如面向对象分析OOA、面向对象设计OOD、面向对象编程实现OOP。
• OOD中建模会用图形化的建模语言UML：
  

在UML 里，一个类的属性能显示它的名字，类型，初始化值，属性也可以显示private public protected

（三）练习

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

• 产品代码

public class Complex {
    static int r;
    static int i;
    private double m;
    private double n;
    public static int getRealPart(int RealPart){
        r = RealPart;
        return r;
    }
    public static int getImaginePart(int ImaginePart){
        i = ImaginePart;
        return i;
    }
    public Complex(double m, double n) {
        this.m = m;
        this.n = n;
    }
    public Complex add(Complex c) {
        return new Complex(m + c.m, n + c.n);
    }
    public Complex minus(Complex c) {
        return new Complex(m - c.m, n - c.n);
    }
    public Complex multiply(Complex c) {
        return new Complex(m * c.m - n * c.n, m * c.n + n * c.m);
    }
    public String toString() {
        String rtr_str = "";
        if (n > 0)
            rtr_str = "(" + m + "+" + n + "i" + ")";
        if (n == 0)
            rtr_str = "(" + m + ")";
        if (n < 0)
            rtr_str = "(" + m + n + "i" + ")";
        return rtr_str;
    }
}

• 测试代码

import org.junit.Test;
import static org.junit.Assert.*;
public class ComplexTest {
    Complex a=new Complex(1,2);
    Complex b=new Complex(1,-4);
    Complex c=new Complex(19,0);
    Complex d=new Complex(0,-3);
    Complex e=new Complex(0,0);
    @Test
    public void getRealPart() throws Exception {
        assertEquals(1, Complex.getRealPart(1));
        assertEquals(-1, Complex.getRealPart(-1));
        assertEquals(5, Complex.getRealPart(5));
        assertEquals(22, Complex.getRealPart(22));
        assertEquals(-100, Complex.getRealPart(-100));
        assertEquals(0, Complex.getRealPart(0));
    }
    @Test
    public void getImaginePart() throws Exception {
        assertEquals(1, Complex.getImaginePart(1));
        assertEquals(-1, Complex.getImaginePart(-1));
        assertEquals(5, Complex.getImaginePart(5));
        assertEquals(22, Complex.getImaginePart(22));
        assertEquals(-100, Complex.getImaginePart(-100));
        assertEquals(0, Complex.getImaginePart(0));
    }
    @Test
    public void add() throws Exception {
        assertEquals("(2.0-2.0i)", a.add(b).toString());
        assertEquals("(20.0+2.0i)", a.add(c).toString());
        assertEquals("(1.0-1.0i)", a.add(d).toString());
        assertEquals("(1.0+2.0i)", a.add(e).toString());
    }
    @Test
    public void minus() throws Exception {
        assertEquals("(0.0+6.0i)", a.minus(b).toString());
        assertEquals("(-18.0+2.0i)", a.minus(c).toString());
        assertEquals("(1.0+5.0i)", a.minus(d).toString());
        assertEquals("(1.0+2.0i)", a.minus(e).toString());
    }
    @Test
    public void multiply() throws Exception {
        assertEquals("(9.0-2.0i)", a.multiply(b).toString());
        assertEquals("(19.0+38.0i)", a.multiply(c).toString());
        assertEquals("(6.0-3.0i)", a.multiply(d).toString());
        assertEquals("(0.0)", a.multiply(e).toString());
    }
}

实验感想

这次的实验是真的难，步骤多，繁琐，最大的问题在于无法将插件JunitGenerator V2.0安装，只能借用室友的电脑完成。
另外，实验形式的多样性固然能够使学生有兴趣，但兴趣是能够被消耗的，到一定程度只会招到我们后进生的“反感”。
2.实验报告中统计自己的PSP(Personal Software Process)时间

步骤	耗时	百分比
需求分析	30min	14.3%
设计	1h	28.6%
代码实现	1h	28.6%
测试	30min	14.3%
分析总结	30min	14.3%