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

一、实验内容

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

二、实验步骤

（一）单元测试
（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 "错误";
   }
}

测试代码：
测试一：

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

运行结果如下：

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

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

运行结果如下：

测试三：异常情况测试

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 "不符合实际情况";

测试四：测试分段结点

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

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

运行结果如下：

继承：以封装为基础，一个类的定义可以基于另外一个已经存在的类，即子类基于父类，从而实现父类代码的重用。其更为广泛而重要的作用是实现多态。

在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：应用该模式的结果和权衡
示例如下：

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
代码如下：

package shiyan2;
public class ComplexNumber
{
 double r,i;
  

public  ComplexNumber(){
	this.r=0;
	this.i=0;
}
public ComplexNumber(double r, double i){
	this.r=r;
	this.i=i;
}
public double GetRealPart(){
	return this.r;
}
public double GetImaginaryPart(){
	return this.i;
}
public void SetRealPart(double r){
	this.r=r;
}
public void SetImaginaryPart(double i){
	this.i=i;
}
public ComplexNumber ComplexAdd(ComplexNumber a,ComplexNumber b)    
{
	ComplexNumber temp = new ComplexNumber();
    temp.r = a.r + b.r;
    temp.i  = a.i  + b.i;
    return temp;
}
public ComplexNumber ComplexMinus(ComplexNumber a,ComplexNumber b)    
{
	ComplexNumber temp =new ComplexNumber();
    temp.r=a.r - b.r;
    temp.i =a.i - b.i;
    return temp;
}    
public ComplexNumber ComplexMulti(ComplexNumber a,ComplexNumber b)    
{
	ComplexNumber temp = new ComplexNumber();
    temp.r = a.r*b.r-a.i*b.i;
    temp.i  = a.r*b.i+a.i*b.r;
    return temp;
}
public void ComplexAdd(ComplexNumber c){
	this.r=this.r+c.r;
	this.i=this.i+c.i;
}


public void ComplexMinus(ComplexNumber c){
	this.r=this.r-c.r;
	this.i=this.i-c.i;
}
public void ComplexMulti(ComplexNumber c)                
{
    double temp=this.r;    
    this.r=this.r*c.r-this.i*c.i;
    this.i =temp*c.i+this.i*c.r;
}
public void printComplexNumber(){
	System.out.print(""+this.r+"+"+this.i+"i");
}

}

测试代码如下：

package shiyan2;

public class txet extends ComplexNumber{
	public static void main(String[] args)        //测试代码
    {
        ComplexNumber cc=new ComplexNumber(4,5);
        cc.printComplexNumber();
        System.out.println();
        ComplexNumber dd=new ComplexNumber(2,4);
        dd.printComplexNumber();
        System.out.println();
        System.out.println("-----------------");
        System.out.println();
        ComplexNumber ff=new ComplexNumber();
        
        ff=ff.ComplexAdd(cc,dd);
        ff.printComplexNumber();
        System.out.println();
        ff=ff.ComplexMinus(cc,dd);
        ff.printComplexNumber();
        System.out.println();
        ff=ff.ComplexMulti(cc,dd);
        ff.printComplexNumber();
        System.out.println();
        
        System.out.println("-----------------");
         
    }
}

测试结果如图：

利用StarUML软件进行UML建模，可以将以上思路进行具象化表示，建模后结果如下：

总结感想：
本次实验中，第一次用到了测试代码，和设计思路方式，开始的时候我只是认为这是无端的增加工作量，代码本身运行后显示出来不就可以了么，之后发现我之前一直理解错了一件事情，一个完整的程序代码不一定非要有打印，只要的逻辑清晰，编译通过，内部功能可以实现就可以了，一直错误的理解成了所以的代码都会有个打印，那才是代码实现的体现，但是很显然是我自己有很大的问题，这次的实验带给的我的，主要是在编写程序代码时的设计思路和挑错思想，就像数据结构老师的所说的话，现在没门课程的实验一定要注意一点，就是尽可能的找错，现在的找出来的错误越多，越说明你的有了提升，不光在代码的编写上，也在对问题考虑的思维方式上。实验二带给我的收获最为让我印象深刻的就是给我之后思考问题时的提升和细致。

PSP时间

步骤	耗时 ：100分钟	百分比
需求分析	10分钟	10%
设计	15分钟	15%
代码实现	45分钟	45%
测试	10分钟	10%
分析总结	20分钟	20%