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

一、实验内容

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

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

3、初步掌握UML建模

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

5、了解设计模式

二、实验步骤

（一）单元测试

（1）三种代码

伪代码：以简洁的自然语言表明设计步骤；

  • 百分制转五分制： 如果成绩小于60，转成“不及格” 如果成绩在60与70之间，转成“及格” 如果成绩在70与80之间，转成“中等” 如果成绩在80与90之间，转成“良好” 如果成绩在90与100之间，转成“优秀” 其他，转成“错误” 产品代码：用以实现特定功能的程序或机器语言；
package exp1;
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 "错误";
   }
}
  • 测试代码：用以对产品代码进行测试的代码；

1、测试一：选取某一合法输入值进行测试

package Test;
public class MyUtilTest {
public static void main(String[] args) {
    // 百分制成绩是50时应该返回五级制的“不及格”
    if(MyUtil.percentage2fivegrade(50) != "不及格")
        System.out.println("test failed!");
    else 
        System.out.println("test passed!");
}
}

2、测试二：全面覆盖各等级段

package Test;
 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!");
}
}

运行结果如下：

3、测试三：异常情况测试

public class MyUtilTest {
public static void main(String[] args) {
    //测试出错情况
    if(MyUtil.percentage2fivegrade(-10) != "错误")
        System.out.println("test failed 1!");
    else if(MyUtil.percentage2fivegrade(115) != "错误")
        System.out.println("test failed 2!");
    else 
        System.out.println("test passed!");
}
}

运行结果如下：

和我们预期的结果不一样，原因是判断不及格时没有要求成绩大于零，因此我们增加对负分的判断：

if ((grade < 0)) return "错误"; 再次运行，测试结果符合预期，如下图所示：

测试四：测试分段结点

package Test;
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!"); 
}
}

运行结果如下：

于是把判断优秀的条件中包含输入为100的情况，对下面代码进行修改：

else if (grade < 100) return "优秀"; 改成

else if (grade <= 100) return "优秀"; 再次运行，测试结果符合预期，如下图所示：

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

  • TDD：先写测试代码，然后再写产品代码的开发方法。
  • TDD的一般步骤如下： 1、明确当前要完成的功能，记录成一个测试列表

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

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

4、编写产品代码

5、测试通过

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

7、循环完成所有功能的开发

在此介绍IDEA下TDD的使用方法：鼠标右键->Go To ->Test

TDD的编码节奏是：

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

（二）面向对象三要素

（1）抽象

即“求同存异、去粗取精”的过程。将若干事物中相同的部分进行剥离整理，并形成具有某特定功能的产品，这一过程即为抽象。过程抽象的结果是函数，数据抽象的结果是抽象数据类型其显而易见的好处是（在程序设计中）减少了代码大重复性，提高了效率。

（2）封装、继承与多态

面向对象(Object-Oriented)的三要素包括：封装、继承、多态。面向对象的思想涉及到软件开发的各个方面，如面向对象分析（OOA）、面向对象设计（OOD）、面向对象编程实现(OOP)。OOA根据抽象关键的问题域来分解系统，关注是什么（what）。OOD是一种提供符号设计系统的面向对象的实现过程，用非常接近问题域术语的方法把系统构造成“现实世界”的对象，关注怎么做（how）,通过模型来实现功能规范。OOP则在设计的基础上用编程语言（如Java）编码。贯穿OOA、OOD和OOP的主线正是抽象。 封装：将与某一将数据与相关行为包装在一起以实现信息就隐藏，核心内容是模块化和信息隐藏，与此相伴的是接口的使用。

1、封装示例：

public class Dog {
private String color;
public String getColor() {
    return color;
}
public void setColor(String color) {
    this.color = color;
}
public String bark(){
    return "汪汪";
}
public String toString(){
    return "The Dog's color is " + this.getColor() +", and it shouts "+ this.bark() + "!";
}
}

检测示例：

public class DogTest {
public static void main(String[] args) {
    Dog d = new Dog();
    d.setColor("Yellow");
    getInfo(d);
}
public static void getInfo(Dog d) {
    System.out.println(d.toString());
}
}

运行结果如下：

  • 利用StarUML软件进行UML建模，可以将以上思路进行具象化表示： 

  • 继承：以封装为基础，一个类的定义可以基于另外一个已经存在的类，即子类基于父类，从而实现父类代码的重用。其更为广泛而重要的作用是实现多态。 2、继承示例：Dog类和Cat类都有Color属性和相应的setter和getter方法，可以通过继承使其精炼化，把Color属性和相应的setter和getter方法放到父类Animal中，代码如下：

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() + "!";
}
}
  • 在Java中，当我们用父类声明引用，用子类生成对象时，多态就出现了。封装、继承与多态是在抽象的基础上进行的“进化”，用于减少重复和赘余。其中很重要的思想就是模块化和信息隐藏。

(三)设计模式

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

  • SRP(Single Responsibility Principle,单一职责原则) 对象提供单一职责的高度封装，对象的改变仅仅依赖于单一职责的改变
  • OCP(Open-Closed Principle,开放-封闭原则) 即对扩充开放（功能可增加），对修改封闭（源代码不可改动）
  • OCP实现手段：（1）抽象和继承，（2）面向接口编程
  • LSP(Liskov Substitusion Principle,Liskov替换原则) 子类必须可以被其基类所代，父类型对象可以被子类型对象所取代
  • ISP(Interface Segregation Principle,接口分离原则) 客户不应该依赖他们并未使用的接口
  • DIP(Dependency Inversion Principle,依赖倒置原则)

（2）模式与设计模式

模式是某外在环境(Context) 下﹐对特定问题(Problem)的惯用解决之道。其中最重要的是设计模式。

（3）设计模式实示例

设计模式四个基本元素 Pattern name：描述模式，便于交流，存档 Problem：描述何处应用该模式 Solution：描述一个设计的组成元素，不针对特例 Consequence：应用该模式的结果和权衡 示例如下：

package exp1;
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(); 
  } 
}

运行结果： （四）练习

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

1.伪代码：

Complex类要输出实部，输出虚部，并按照a+bi的形式输出复数。 Complex类中有两个变量，实部RealPart和虚部ImaginePart；

方法：

getRealPart(int RealPart);返回实部 getImaginePart(int ImaginePart);返回虚部 add(Complex c);实现复数相加 minus(Complex c);实现复数相减 multiply(Complex c);实现复数相乘 toString(int RealPart,int ImaginePart);将复数输出成a+bi的格式。

2.测试代码：

package Test;
import exp1.MyComplex;
import org.junit.Test;
import static org.junit.Assert.*;
public class MyComplexTest {
    MyComplex a=new MyComplex(1,2);
    MyComplex b=new MyComplex(1,-4);
    MyComplex c=new MyComplex(19,0);
    MyComplex d=new MyComplex(0,-3);
    MyComplex e=new MyComplex(0,0);
    @Test
    public void getRealPart() throws Exception {
        assertEquals(1, MyComplex.getRealPart(1));
        assertEquals(-1, MyComplex.getRealPart(-1));
        assertEquals(5, MyComplex.getRealPart(5));
        assertEquals(22, MyComplex.getRealPart(22));
        assertEquals(-100, MyComplex.getRealPart(-100));
        assertEquals(0, MyComplex.getRealPart(0));
    }
    @Test
    public void getImaginePart() throws Exception {
        assertEquals(1, MyComplex.getImaginePart(1));
        assertEquals(-1, MyComplex.getImaginePart(-1));
        assertEquals(5, MyComplex.getImaginePart(5));
        assertEquals(22, MyComplex.getImaginePart(22));
        assertEquals(-100, MyComplex.getImaginePart(-100));
        assertEquals(0, MyComplex.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());
    }
}

单元测试运行通过:

3.产品代码:

PSP(Personal Software Process)时间

步骤耗时百分比
需求分析 10min 9.1%
设计 15min 13.6%
代码实现 40min 36.4%
测试 25min 22.7%
分析总结 20min 18.2%

总结

这次最大的收获就是学会了Junit单元测试，从表面上看，每个单元程序都编写测试代码似乎是增加了工作量，但是其实这些代码不仅为你织起了一张保护网，而且还可以帮助你快速定位错误从而使你大大减少修复BUG的时间。