20155229实验二 《Java面向对象程序设计》实验报告

20155229实验二 《Java面向对象程序设计》实验报告

实验内容

1. 初步掌握单元测试和TDD

2. 理解并掌握面向对象三要素：封装、继承、多态

3. 初步掌握UML建模

4. 熟悉S.O.L.I.D原则

5. 了解设计模式

实验题目

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

题目2.参考 积极主动敲代码使用JUnit学习Java,以 TDD的方式研究学习StringBuffer

题目3.Java面向对象程序设计(http://www.cnblogs.com/rocedu/p/4472842.html)

对设计模式示例进行扩充，体会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){
        //如果成绩小于0，转成“错误”
        if ((grade < 0))
            return "错误";
            //如果成绩小于60，转成“不及格”
        else 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 "优秀";
            //如果成绩大于100，转成“错误”
        else
            return "错误";
    }
}

我们在运行代码有时候会出现错误，这个时候就需要检测所写代码的边缘，避免出现bug。

• 测试代码

public class MyUtilTest {
    public static void main(String[] args) {
        if(MyUtil.percentage2fivegrade(55) != "不及格")
            System.out.println("test failed!");
        else if(MyUtil.percentage2fivegrade(65) != "及格")
            System.out.println("test failed!");
        else if(MyUtil.percentage2fivegrade(75) != "中等")
            System.out.println("test failed!");
        else if(MyUtil.percentage2fivegrade(85) != "良好")
            System.out.println("test failed!");
        else if(MyUtil.percentage2fivegrade(95) != "优秀")
            System.out.println("test failed!");
        else
            System.out.println("test passed!");
    }
}

但是上述的代码运行后会出现 test passed 这样的显示，所以我们可以选用单元测试工具JUnit来重做上述的题目。

import org.junit.Test;
import junit.framework.TestCase; //注意导包！！！
public class MyUtilTest extends TestCase {
    @Test
    public void testNormal() {
        assertEquals("不及格", MyUtil.percentage2fivegrade(55));
        assertEquals("及格", MyUtil.percentage2fivegrade(65));
        assertEquals("中等", MyUtil.percentage2fivegrade(75));
        assertEquals("良好", MyUtil.percentage2fivegrade(85));
        assertEquals("优秀", MyUtil.percentage2fivegrade(95));
    }
}

根据这样的代码，可以考虑当输入的数<0，或者>100的情况来进行编写

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

TDD的一般步骤如下：

明确当前要完成的功能，记录成一个测试列表

快速完成编写针对此功能的测试用例

测试代码编译不通过（没产品代码呢）

编写产品代码

测试通过

对代码进行重构，并保证测试通过（重构下次实验练习）

循环完成所有功能的开发

以 TDD的方式研究学习StringBuffer

根据老师给的代码，进行对Junit的应用。

public class StringBufferDemo{
  public static void main(String [] args){
     StringBuffer buffer = new StringBuffer(20);
     buffer.append('S');
     buffer.append("tringBuffer");
     System.out.println(buffer.charAt(1));
     System.out.println(buffer.capacity();
     System.out.println(buffer.indexOf("tring12345"));
     System.out.println("buffer = " + buffer.toString());
     System.out.println(buffer.length());
 }
}

产品代码：

public class StringBufferDemo{
   StringBuffer buffer = new StringBuffer();
   public StringBufferDemo(StringBuffer buffer){
       this.buffer = buffer;
   }
   public Character charAt(int i){
       return buffer.charAt(i);
   }
   public int capacity(){
       return buffer.capacity();
   }
   public int length(){
       return buffer.length();
   }
   public int indexOf(String buf) {
       return buffer.indexOf(buf);
   }
}

测试代码及结果为：

（3）对设计模式示例进行扩充，体会OCP原则和DIP原则的应用，初步理解设计模式

S.O.L.I.D原则

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

SRP(Single Responsibility Principle,单一职责原则)

OCP(Open-Closed Principle,开放-封闭原则)

LSP(Liskov Substitusion Principle,Liskov替换原则)

ISP(Interface Segregation Principle,接口分离原则)

DIP(Dependency Inversion Principle,依赖倒置原则)

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

老师给了Int型的代码，如下：

class Integer {
   int value;
   public Integer(){
      value=100;
   }
   public void DisplayValue(){
        System.out.println(value);
   }
}
class Document {
   Integer pi;
   public Document(){
       pi = new Integer();
   }
   public void DisplayData(){
      pi.DisplayValue();
   }
}
public class MyDoc{
   static Document d;
   public static void main(String [] args) {
        d = new Document();
        d.DisplayData();
  }
}

我的代码及结果:

(4)任务：以TDD的方式开发一个复数类Complex

• 要求：（伪代码）

// 定义属性并生成getter,setter
double RealPart;
double ImagePart;
// 定义构造函数
public Complex()
public Complex(double R,double I)

//Override Object
public boolean equals(Object obj)
public String toString()

// 定义公有方法:加减乘除
Complex ComplexAdd(Complex a)
Complex ComplexSub(Complex a)
Complex ComplexMulti(Complex a)
Complex ComplexDiv(Complex a)

• 产品代码

public class Complex {
    private double r;
    private double i;

    public Complex(double r, double i) {
        this.r = r;
        this.i = i;
    }

    public static double getRealPart(double r) {
        return r;
    }

    public static double getImagePart(double i) {
        return i;
    }

    public Complex ComplexAdd(Complex c) {
        return new Complex(r + c.r, i + c.i);
    }

    public Complex ComplexSub(Complex c) {
        return new Complex(r - c.r, i - c.i);
    }

    public Complex ComplexMulti(Complex c) {
        return new Complex(r * c.r - i * c.i, r * c.i + i * c.r);
    }

    public Complex ComplexDiv(Complex c) {
        return new Complex((r * c.i + i * c.r) / (c.i * c.i + c.r * c.r), (i * c.i + r * c.r) / (c.i * c.i + c.r * c.r));
    }

    public String toString() {
        String s = " ";
        if (i > 0)
            s = r + "+" + i + "i";
        if (i == 0)
            s = r + "";
        if (i < 0)
            s = r + " " + i + "i";
        return s;
    }
}

• 测试代码及结果

（5）使用StarUML对实验二中的代码进行建模

在老师的教程下，下载了StarUML，并进行了运用

实验总结与体会

本次实验相较于第一次实验明显提高了难度。

通过本次实验，我了解了伪代码``产品代码``测试代码三种代码的区别，并且在Idea中运用了Juint对测试代码进行了很好的运用；对设计模式示例进行了扩充，体会了OCP原则和DIP原则；用TDD实现了负数类Complex，最后运用StarUML对面向对象三要素有了更深的理解。

我的PSP时间

步骤	耗时	百分比
需求分析	20分钟	12.5 %
设计	30分钟	18.75%
代码实现	80分钟	50%
测试	20分钟	12.5%
分析总结	10分钟	6.25%

参考资料

• 实验二 Java面向对象程序设计
• 单元测试
• 积极主动敲代码，使用JUnit学习Java