20155330 实验二 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 "错误";

    }

}

测试代码

60分测试

public class MyUtilTest {

    public static void main(String[] args) {

    // 百分制成绩是60时应该返回五级制的“及格”

        if(MyUtil.percentage2fivegrade(60) != "及格")

            System.out.println("test failed!");

        else

            System.out.println("test passed!");

    }

}

测试结果：

输入负分/超过100分

public class MyUtilTest {

    public static void main(String[] args) {

//测试出错情况

        if(MyUtil.percentage2fivegrade(-1) != "错误")

            System.out.println("test failed 1!");

        else if(MyUtil.percentage2fivegrade(101) != "错误")

            System.out.println("test failed 2!");

        else

            System.out.println("test passed!");

    }

}

测试结果：

增加边界及异常（输入为负分/超过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 "错误";

    }

}

测试代码

public class MyUtilTest {

    public static void main(String[] args) {

    //测试正常情况

    if(MyUtil.percentage2fivegrade(55) != "不及格")

        System.out.println("test failed 1!");

    else if(MyUtil.percentage2fivegrade(65) != "及格")

        System.out.println("test failed 2!");

    else if(MyUtil.percentage2fivegrade(75) != "中等")

        System.out.println("test failed 3!");

    else if(MyUtil.percentage2fivegrade(85) != "良好")

        System.out.println("test failed 4!");

    else if(MyUtil.percentage2fivegrade(95) != "优秀")

        System.out.println("test failed 5!");

    //测试出错情况

    else if(MyUtil.percentage2fivegrade(-1) != "错误")

        System.out.println("test failed 6!");

    else if(MyUtil.percentage2fivegrade(101) != "错误")

        System.out.println("test failed 7!");

    //测试边界情况

    else if(MyUtil.percentage2fivegrade(0) != "不及格")

        System.out.println("test failed 8!");

    else if(MyUtil.percentage2fivegrade(60) != "及格")

        System.out.println("test failed 9!");

    else if(MyUtil.percentage2fivegrade(70) != "中等")

        System.out.println("test failed 10!");

    else if(MyUtil.percentage2fivegrade(80) != "良好")

        System.out.println("test failed 11!");

    else if(MyUtil.percentage2fivegrade(90) != "优秀")

        System.out.println("test failed 12!");

    else if(MyUtil.percentage2fivegrade(100) != "优秀")

        System.out.println("test failed 13!");

    else

        System.out.println("test passed!");

    }

}

测试结果：

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

TDD的一般步骤如下：
明确当前要完成的功能，记录成一个测试列表
快速完成编写针对此功能的测试用例
测试代码编译不通过（没产品代码呢）
编写产品代码
测试通过
对代码进行重构，并保证测试通过（重构下次实验练习）
循环完成所有功能的开发
IDEA TDD 使用：参考Intellj IDEA 简易教程-单元测试;积极主动敲代码，使用JUnit学习Jav
对MyUtil进行单元测试：
TDD的编码节奏是
1. 增加测试代码，JUnit出现红条
2. 修改产品代码
3. JUnit出现绿条，任务完成

（二）面向对象三要素

（1）抽象

"去粗取精、化繁为简、由表及里、异中求同"。抽象就是抽出事物的本质特征而暂时不考虑他们的细节。对于复杂系统问题人们借助分层次抽象的方法进行问题求解；在抽象的最高层，可以使用问题环境的语言，以概括的方式叙述问题的解。在抽象的较低层，则采用过程化的方式进行描述。在描述问题解时，使用面向问题和面向实现的术语。程序设计中，抽象包括两个方面，一是过程抽象，二是数据抽象。

（2）封装、继承与多态

面向对象(Object-Oriented)的三要素包括：封装、继承、多态。过程抽象的结果是函数，数据抽象的结果是抽象数据类型（Abstract Data Type，ADT），类可以作具有继承和多态机制的ADT。数据抽象才是OOP的核心和起源。

OO三要素的第一个要素是封装，封装就是将数据与相关行为包装在一起以实现信息就隐藏。Java中用类进行封装。

封装实际上使用方法(method)将类的数据隐藏起来，控制用户对类的修改和访问数据的程度,从而带来模块化(Modularity)和信息隐藏(Information hiding)的好处；接口（interface）是封装的准确描述手段。

对应代码:

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 Dog extends Animal{

    public String shout(){

        return "汪汪";

    }

       public String toString(){

        return "The Dog's color is " + this.getColor() +", and it shouts "+ this.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() + "!";

    }

}

（三）设计模式初步

（1）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,依赖倒置原则)

（2）模式与设计模式

计算机科学中有很多模式:

GRASP模式

分析模式

软件体系结构模式

设计模式：创建型，结构型，行为型

管理模式： The Manager Pool 实现模式

界面设计交互模式

…

这里面最重要的是设计模式

（3）设计模式实示例

设计模式有四个基本要素：

Pattern name：描述模式，便于交流，存档

Problem：描述何处应用该模式

Solution：描述一个设计的组成元素，不针对特例

Consequence：应用该模式的结果和权衡（trade-offs）

（四）练习

(1)使用TDD的方式设计关实现复数类Complex

伪代码

构造函数，将实部，虚部都置为0

构造函数，创建复数对象的同时完成复数的实部，虚部的初始化

设置实部，设置虚部:复数相加、复数相减、复数相乘

产品代码

 public class Complex {

    private double realPart;

    private double imaginPart;

    public Complex(){

        double realPart;

        double imaginPart;

    }

    public Complex(double r,double i){

        double realPart;

        double imaginPart;

        this.realPart=r;

        this.imaginPart=i;

    }

    public double getRealPart(){

        return realPart;

    }

    public double getImaginPart(){

        return imaginPart;

    }

    public void setRealPart(double d){

        this.realPart=d;

    }

    public void setImaginPart(double d) {

        this.imaginPart =d;

    }

    public void ComplexAdd(Complex c){

        this.realPart+=c.realPart;

        this.imaginPart+=c.imaginPart;

    }

    public void ComplexAdd(double c){

        this.realPart+=c;

    }

    public void ComplexMinus(Complex c){

        this.realPart-=c.realPart;

        this.imaginPart-=c.imaginPart;

    }

    public void ComplexMinus(double c){

        this.realPart-=c;

    }

    public void ComplexMulti(Complex c){

        this.realPart*=c.realPart;

        this.imaginPart*=c.imaginPart;

    }

    public void ComplexMulti(double c){

        this.realPart*=c;

    }

    }

测试代码

import junit.framework.TestCase;

public class ComplexTest extends TestCase {

    Complex c1 = new Complex(3, 5);

    Complex c2 = new Complex(3, 5);

    double a = 5;

    public void testComplexAdd() throws Exception {

        c1.ComplexAdd(c2);

        assertEquals(6.0, c1.getRealPart());

        assertEquals(10.0, c1.getImaginPart());

    }

    public void testComplexMinus() throws Exception {

        c1.ComplexMinus(c2);

        assertEquals(0.0, c1.getRealPart());

        assertEquals(0.0, c1.getImaginPart());

    }

    public void testComplexMulti() throws Exception {

        c1.ComplexMulti(c2);

        assertEquals(9.0, c1.getRealPart());

        assertEquals(25.0, c1.getImaginPart());

    }

}

单元测试运行通过：

(2)用自己的学号（20155330）%6进行取余运算，根据结果进行代码扩充：

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

原代码：

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();

  }

}

修改后的代码：

// Server Classes

abstract class Data {

    abstract public void DisplayValue();

}

class Byte extends  Data {

    int value;

    Byte() {

        value=100;

    }

    public void DisplayValue(){

        System.out.println (value);

    }

}

// Pattern Classes

abstract class Factory {

    abstract public Data CreateDataObject();

}

class ByteFactory extends Factory {

    public Data CreateDataObject(){

        return new Byte();

    }

}

//Client classes

class Document {

    Data pd;

    Document(Factory pf){

        pd = pf.CreateDataObject();

    }

    public void DisplayData(){

        pd.DisplayValue();

    }

}

//Test class

public class MyDoc {

    static Document d;

    public static void main(String[] args) {

        d = new Document(new ByteFactory());

        d.DisplayData();

    }

}

运行结果如下：

实验总结

这次实验相对上一次内容更多，需要学习的地方更加细化。在实验中遇到的困难主要出现在TDD单元测试部分。不知道出于什么原因在IDEA中使用老师的方法无法下载JUnitGeneratorV2.0.jar文件，最后是在网页JUnitGeneratorV2.0中下载后利用加入本地文件的方式才可以使用。

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