2016-2017-2 20155339 实验二《Java面向对象程序设计》实验报告

实验内容

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

实验内容

1.参考Intellj IDEA 简易教程

提交最后三个测试用例都通过的截图，截图上要有画图加水印，输入自己的学号。

2.参考积极主动敲代码使用JUnit学习Java,

以 TDD的方式研究学习StringBuffer，提交你的单元测试用例和测试通过的截图，截图要加上学号水印。

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

对设计模式示例进行扩充，体会OCP原则和DIP原则的应用，初步理解设计模式用自己的学号%6进行取余运算，根据结果进行代码扩充：

0：让系统支持Byte类，并在MyDoc类中添加测试代码表明添加正确

1：让系统支持Short类，并在MyDoc类中添加测试代码表明添加正确

2：让系统支持Boolean类，并在MyDoc类中添加测试代码表明添加正确

3：让系统支持Long类，并在MyDoc类中添加测试代码表明添加正确

4：让系统支持Float类，并在MyDoc类中添加测试代码表明添加正确

5：让系统支持Double类，并在MyDoc类中添加测试代码表明添加正确

4.以TDD的方式开发一个复数类Complex支持加减乘除。

5.使用StarUML对实验二中的代码进行建模，发类图的截图，加上学号水印。类图中至少两个类。

实验步骤

（一）单元测试

（1）三种代码

伪代码

百分制转五分制：

   如果成绩小于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 "错误";

   }

}

测试代码

为了检测代码的健硕性，避免出现bug需要对代码进行测试，这个时候就需要使用测试代码。

编写测试代码
一般情况测试

代码，结果如下
边界测试

对输入为“0，60，70，80，90，100”这些边界情况进行测试的代码，得到如下结果

出现了问题，对这个问题进行修复，得到代码2，再次进行测试，得到如下结果

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

TDD的一般步骤如下：

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

实验步骤

一、学习在IDEA下使用TDD并安装JunitGenerator V2.0

在IDEA中使用TDD可以参考老师的Intellj IDEA 简易教程，按照老师的步骤一步一步进行，只到安装JunitGenerator V2.0时出现了问题，教程中是说在设置对话框中选择Plugins, 单击Install JetBrains plugin...按钮打开插件安装界面，然后在插件安装对话框的搜索中输入junit,单击JunitGenerator V2.0,单击右边绿色的Install1按钮安装，但是在我单击Install JetBrains plugin...按钮打开插件安装界面时找不到JunitGenerator V2.0，只有下面这个插件

经过多次探索，发现如下步骤可以找到需要安装的内容：在设置对话框中选择Plugins，然后单击Browse repositories...按钮（如下图）打开插件安装界面，然后又教程相同，在插件安装对话框的搜索中输入junit,单击JunitGenerator V2.0,单击右边绿色的Install1按钮安装。

使用TDD

TDD的编码节奏是：

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

通过TDD完成了本次实验任务的1，2和4，在这里给出通过TDD学习的代码链接并且测试通过的截图

第一个实验题目的产品代码测试代码以及结果截图

第二个实验题目的产品代码，测试代码以及结果截图

第四个实验题目的产品代码，测试代码，以及运行结果截图

（二）面向对象三要素

（1）抽象

抽象一词的本意是指人在认识思维活动中对事物表象因素的舍弃和对本质因素的抽取。抽象是人类认识复杂事物和现象时经常使用的思维工具，抽象思维能力在程序设计中非常重要，"去粗取精、化繁为简、由表及里、异中求同"的抽象能力很大程度上决定了程序员的程序设计能力。
抽象就是抽出事物的本质特征而暂时不考虑他们的细节。对于复杂系统问题人们借助分层次抽象的方法进行问题求解；在抽象的最高层，可以使用问题环境的语言，以概括的方式叙述问题的解。在抽象的较低层，则采用过程化的方式进行描述。在描述问题解时，使用面向问题和面向实现的术语。

程序设计中，抽象包括两个方面，一是过程抽象，二是数据抽象。

（2）封装、继承与多态

面向对象(Object-Oriented)的三要素包括：封装、继承、多态。
面向对象的思想涉及到软件开发的各个方面，如面向对象分析（OOA）、面向对象设计（OOD）、面向对象编程实现(OOP)。
OOD中建模会用图形化的建模语言UML（Unified Modeling Language）,UML是一种通用的建模语言

通过次数的学习完成了实验的第五个内容。

步骤如下：

1.下载安装 StarUML，并学习使用。

2.学习教程中的代码

public abstract class Animal {

    private String color;

    public String getColor() {

        return color;

    }

    public void setColor(String color) {

        this.color = color;

    }

    public abstract String shout();

}

public class Cat extends Animal{

    public String shout(){

        return "喵喵";

    }

    public String toString(){

        return "The Cat's color is " + this.getColor() +", and it shouts "+ this.shout() + "!";

    }

}

public class Dog extends Animal{

    public String shout(){

        return "汪汪";

    }

    public String toString(){

        return "The Dog's color is " + this.getColor() +", and it shouts "+ this.shout() + "!";

    }

}

3.利用StarUML完成建模，得到如下图所示

（三）设计模式初步

（1）S.O.L.I.D原则

面向对象三要素是“封装、继承、多态”，任何面向对象编程语言都会在语法上支持这三要素。
如何借助抽象思维用好三要素特别是多态还是非常困难的，S.O.L.I.D类设计原则是一个很好的指导，它包括SRP(单一职责原则)、

OCP(开放-封闭原则)、

LSP(替换原则)、

ISP(接口分离原则)、

DIP(依赖倒置原则)。
设计模式：创建型，结构型，行为型

通过这部分的学习完成了本次实验的第三个内容，学号模6后我的实验题目是3。我通过已有的代码新建了一个long类来继承Data，如下

class Long extends  Data {

    int value;

    Long() {

        value=1234567890;

    }

    public void DisplayValue(){

        System.out.println (value);

    }

}

再建立了一个LongFactory类来继承Factory，如下

class LongFactory extends Factory {

    public Data CreateDataObject(){

        return new Long();

    }

}

这样程序是支持Long类的，再在主类中增加测试代码，验证并且展示我的程序是否支持long型，测试代码为

d = new Document(new LongFactory());

        d.DisplayData();

程序结果截图如下

（四）练习

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

伪代码

Complex类

定义实部以及虚部；

方法Set设置实部,以及虚部：public  double setRealPart()，public double setImagePart();

方法Get取得实部，以及虚部：public  double getRealPart()，public double getImagePart();

方法加法Complex ComplexAdd(Complex a)

方法减法Complex ComplexSub(Complex a)

方法乘法Complex ComplexMultib(Complex a)

方法除法Complex ComplexDiv(Complex a)

方法toString()控制输出格式

产品代码

public class Complex {

    double RealPart;

    double ImagePart;

    public Complex(){

        this.ImagePart=0;

        this.RealPart=0;

    }

    public Complex(double RealPart, double ImagePart) {

        this.RealPart = RealPart;

        this.ImagePart = ImagePart;

    }

    public  double getRealPart(){

        return this.RealPart;

    }

    public double getImagePart(){

        return this.ImagePart;

    }

    public double setRealPart(double R){

        this.RealPart = R;

        return R;

    }

    public double setImagePart(double I){

        this.ImagePart = I;

        return I;

    }

    Complex ComplexAdd(Complex a){

        double R = a.getRealPart();

        double I = a.getImagePart();

        double cr = R + this.RealPart;

        double ci = I + this.ImagePart;

        Complex c = new Complex(cr,ci);

        return c;

    }

    Complex ComplexSub(Complex a){

        double R = a.getRealPart();

        double I = a.getImagePart();

        double cr = R - this.RealPart;

        double ci = I - this.ImagePart;

        Complex c = new Complex(cr,ci);

        return c;

    }

    Complex ComplexMultib(Complex a){

        double R = a.getRealPart();

        double I = a.getImagePart();

        double cr = R * this.RealPart;

        double ci = I * this.ImagePart;

        Complex c = new Complex(cr,ci);

        return c;

    }

    Complex ComplexDiv(Complex a){

        double R = a.getRealPart();

        double I = a.getImagePart();

        double cr = R / this.RealPart;

        double ci = I / this.ImagePart;

        Complex c = new Complex(cr,ci);

        return c;

    }

    public String toString() {

        String complex=new String();

        if (ImagePart > 0)

            complex = "(" + RealPart + "+" + ImagePart + "i" + ")";

        if (ImagePart == 0)

            complex = "(" + RealPart + ")" ;

        if (ImagePart < 0)

            complex = "(" + RealPart + "-" + ImagePart + "i" + ")";

        return complex;

    }

}

测试代码

import junit.framework.TestCase;

import org.testng.annotations.Test;

import java.math.BigDecimal;

/**

 * Created by hp on 2017/4/20.

 */

public class ComplexTest extends TestCase {

    Complex a=new Complex(14,4);

    Complex b=new Complex(5,-2);

    Complex c=new Complex(2,1);

    Complex d=new Complex(4,0);

    Complex m=new Complex();

    @Test

    public void testGetRealPart() throws Exception {

        assertEquals(14.0,a.getRealPart());

        assertEquals(5.0,b.getRealPart());

    }

    @Test

    public void testGetImagePart() throws Exception {

        assertEquals(4.0,a.getImagePart());

        assertEquals(-2.0,b.getImagePart());

    }

    @Test

    public void testSetRealPart() throws Exception {

        m.setRealPart(1);

        assertEquals(1.0,m.getRealPart());

    }

    @Test

    public void testSetImagePart() throws Exception {

        m.setImagePart(4);

        assertEquals(4.0,m.getImagePart());

    }

    @Test

    public void testComplexAdd() throws Exception {

        m=a.ComplexAdd(b);

        assertEquals("(19.0+2.0i)",m.toString());

        m=a.ComplexAdd(c);

        assertEquals("(16.0+5.0i)",m.toString());

    }

    @Test

    public void testComplexSub() throws Exception {

        m=b.ComplexSub(a);

        assertEquals("(9.0+6.0i)",m.toString());

        m=c.ComplexSub(b);

        assertEquals("(3.0--3.0i)",m.toString());

    }

    @Test

    public void testComplexMultib() throws Exception {

        m=a.ComplexMultib(b);

        assertEquals("(70.0--8.0i)",m.toString());

        m=a.ComplexMultib(c);

        assertEquals("(28.0+4.0i)",m.toString());

    }

    @Test

    public void testComplexDiv() throws Exception {

        m=c.ComplexDiv(a);

        assertEquals("(7.0+4.0i)",m.toString());

        m=c.ComplexDiv(b);

        assertEquals("(2.5--2.0i)",m.toString());

    }

}

测试通过截图

我的PSP时间

步骤	耗时	百分比
需求分析	10min	8
设计	20min	15
代码实现	50min	39
测试	30min	23
分析总结	20min	15

心得体会

本次实验中学到了很多东西，包括用TDD测试代码，用UML对代码进行建模等等，花费的时间也比较多，在设计以及练习的过程中也学会了怎么去解决问题，对于这次学到的单元测试，我觉得对我日后对java的学习会有一定的帮助。