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

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

实验内容

-初步掌握单元测试和TDD

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

实验步骤

单元测试

1.三种代码：伪代码、产品代码、测试代码。
我们应该先写伪代码理清思路->再用特定编程语言翻译成产品代码->最后写测试代码，验证自己的代码有没有问题。
(1)伪代码

百分制转五分制：
如果成绩小于60，转成“不及格”
如果成绩在60与70之间，转成“及格”
如果成绩在70与80之间，转成“中等”
如果成绩在80与90之间，转成“良好”
如果成绩在90与100之间，转成“优秀”
其他，转成“错误”

(2)产品代码

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 "错误";
    }
}

(3)测试代码

用50分测试时：

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

输入负分或大于100时：

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

测试边界情况：

public class MyUtilTest4{
public static void main(String[] args) {
//测试边界情况
if(MyUtil2.percentage2fivegrade(0) != "不及格")
System.out.println("test failed 1!");
else if(MyUtil2.percentage2fivegrade(60) != "及格")
System.out.println("test failed 2!");
else if(MyUtil2.percentage2fivegrade(70) != "中等")
System.out.println("test failed 3!");
else if(MyUtil2.percentage2fivegrade(80) != "良好")
System.out.println("test failed 4!");
else if(MyUtil2.percentage2fivegrade(90) != "优秀")
System.out.println("test failed 5!");
else if(MyUtil3.percentage2fivegrade(100) != "优秀")
System.out.println("test failed 6!");
else
System.out.println("test passed!");
}
}

改正错误后最后代码：

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 "错误";
}
}

步骤如下：

• 新建主类
• 将鼠标放在主类类名上，点击出现的黄色小灯泡，在下拉选项中选择Create Test
• 随后在Testing Library中的下拉选项中选择Junit 3，点击OK便可创建Test类
  

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

概念：先写测试代码，然后再写产品代码的开发方法
一般步骤如下：

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

测试代码如下（注意@Test）

public class StringBufferDemoTest extends TestCase {
    StringBuffer a = new StringBuffer("StringBuffer");//测试12个字符（<=16）
    StringBuffer b = new StringBuffer("StringBufferStringBuffer");//测试24个字符（>16&&<=34）
    StringBuffer c = new StringBuffer("StringBufferStringBufferStringBuffer");//测试36个字符（>=34）
    @Test
    public void testcharAt() throws Exception{
        assertEquals('S',a.charAt(0));
        assertEquals('g',a.charAt(5));
        assertEquals('r',a.charAt(11));
    }
    @Test
    public void testcapacity() throws Exception{
        assertEquals(28,a.capacity());
        assertEquals(40,b.capacity());
        assertEquals(52,c.capacity());
    }
    @Test
    public void testlength() throws Exception{
        assertEquals(12,a.length());
        assertEquals(24,b.length());
        assertEquals(36,c.length());
    }
    @Test
    public void testindexOf() throws Exception{
        assertEquals(0,a.indexOf("Str"));
        assertEquals(5,a.indexOf("gBu"));
        assertEquals(10,a.indexOf("er"));
    }
}

结果截图

面向对象三要素

1.抽象：去粗取精、化繁为简、由表及里、异中求同。在抽象的最高层，可以使用问题环境的语言，以概括的方式叙述问题的解；在抽象的较低层，则采用过程化的方式进行描述。
2.面向对象(Object-Oriented)的三要素包括：封装、继承、多态。面向对象的思想涉及到软件开发的各个方面，如面向对象分析（OOA）、面向对象设计（OOD）、面向对象编程实现(OOP)。
3.继承
以封装为基础，一个类的定义可以基于另外一个已经存在的类，即子类基于父类，从而实现父类代码的重用。其更为广泛而重要的作用是实现多态。
示例：Dog类和Cat类都有Color属性和相应的setter和getter方法，可以通过继承使其精炼化，把Color属性和相应的setter和getter方法放到父类Animal中。

UML类图要展示类之间的静态关系，UML中依赖用带箭头的直线表示，例如上例中的Animal类依赖Cat类和Dog类
UML类图中继承的表示法，是用一个带三角的直线指向父类，例如上例中Cat类和Dog类继承Animal类，消除了Dog类和Cat类中的重复代码，符合DRY的要求
设计模式初步

3.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.模式与设计模式：模式是某外在环境(Context) 下﹐对特定问题(Problem)的惯用解决之道(Solution)。计算机科学中有很多模式:

GRASP模式
分析模式
软件体系结构模式
设计模式：创建型，结构型，行为型
管理模式： The Manager Pool 实现模式
界面设计交互模式
3.设计模式实示例：设计模式(design pattern)提供一个用于细化软件系统的子系统或组件，或它们之间的关系图，它描述通信组件的公共再现结构，通信组件可以解决特定语境中的一个设计问题。设计模式有四个基本要素：

示例：

import java.util.Objects;
  abstract class Data {
  abstract public void DisplayValue();
  }
  class Integer extends Data {
  int value;
  Integer() {
      value=100;
  }
  public void DisplayValue(){
     System.out.println (value);
  }
  }
  class Long extends Data {
  long value;
  Long() {
      value=2147483647;
  }
  public void DisplayValue(){
      System.out.println (value);
  }
  }
  class Float extends Data {
  float value;
  Float() {
      value=(float)20165322.0;
  }
  public void DisplayValue(){
      System.out.println (value);
  }
  }
  // Pattern Classes
  abstract class Factory {
  abstract public Data CreateDataObject();
  }
  class IntFactory extends Factory {
  public Data CreateDataObject(){
      return new Integer();
  }
  }
  class LongFactory extends Factory {
  public Data CreateDataObject(){
      return new Long();
  }
  }
  class FloatFactory extends Factory {
  public Data CreateDataObject(){
      return new Float();
  }
  }
  //Client classes
  class Document {
  Data data;
  Document(Factory factory){
      data = factory.CreateDataObject();
  }
  public void DisplayData(){
      data.DisplayValue();
  }
  }
  public class MyDoc {
  static Document d;
  MyDoc(Document d) {
      this.d = d;
  }
  public static void main(String[] args) {
      d = new Document(new FloatFactory());
      d.DisplayData();
  }
  }
}

运行结果

练习

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

伪代码

1）复数类ComplexNumber的属性
realPart: 实部，代表复数的实数部分
imaginPart:　虚部，代表复数的虚数部分
2）复数类ComplexNumber的方法
ComplexNumber()　构造函数，将实部，虚部都置为0
ComplexNumber(double realPart, double imaginPart)　构造函数，创建复数对象的同时完成复数的实部，虚部的初始化
getRealPart()　获取实部
getImaginaryPart()　获取虚部
getRealPart(double realPart)　设置实部
getImaginaryPart(double imaginPart)　设置虚部
ComplexAdd(ComplexNumber c)　 复数相加
ComplexAdd(double realPart2)　 复数相加
ComplexMinus(ComplexNumber c)　 复数相减
ComplexMinus(double realPart2)　复数相减
ComplexMulti(ComplexNumber c)　 复数相乘
ComplexMulti(double realPart2)　复数相乘
toString() 把当前复数对象的实部，虚部组合成a+bi的字符串形式

测试代码

import static junit.framework.Assert.*;
import junit.framework.TestCase;
import org.junit.Test;

public class ComplexNumberTest extends TestCase {
ComplexNumber c1 = new ComplexNumber(3,5);
ComplexNumber c2 = new ComplexNumber(3,5);
double a = 5;
@Test
public void testAdd1() throws Exception {
c1.ComplexAdd(c2);
assertEquals(6.0, c1.getRealPart());
assertEquals(10.0, c1.getImaginPart());
}
@Test
public void testAdd2() throws Exception {
c1.ComplexAdd(a);
assertEquals(8.0, c1.getRealPart());
assertEquals(5.0, c1.getImaginPart());
}
@Test
public void testMinus1() throws Exception {
c1.ComplexMinus(c2);
assertEquals(0.0, c1.getRealPart());
assertEquals(0.0, c1.getImaginPart());
}
public void testMinus2() throws Exception {
c1.ComplexMinus(a);
assertEquals(-2.0, c1.getRealPart());
assertEquals(5.0, c1.getImaginPart());
}
@Test
public void testMulti1() throws Exception {
c1.ComplexMulti(c2);
assertEquals(9.0, c1.getRealPart());
assertEquals(25.0, c1.getImaginPart());
}
public void testMulti2() throws Exception {
c1.ComplexMulti(a);
assertEquals(15.0, c1.getRealPart());
assertEquals(5.0, c1.getImaginPart());
}
}

产品代码

public class ComplexNumber {
private double realPart;
private double imaginPart;
public ComplexNumber(){
this.realPart = 0.0.;
this.imaginPart = 0.0;
}
public ComplexNumber(double r, double i){
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(ComplexNumber c){
this.realPart += c.realPart;
this.imaginPart += c.imaginPart;
}
public void ComplexAdd(double c){
this.realPart += c;
}
public void ComplexMinus(ComplexNumber c){
this.realPart -= c.realPart;
this.imaginPart -= c.imaginPart;
}
public void ComplexMinus(double c){
this.realPart -= c;
}
public void ComplexMulti(ComplexNumber c){
this.realPart = c.realPart;
this.imaginPart = c.imaginPart;
}
public void ComplexMulti(double c){
this.realPart *= c;
}
@Override
public String toString(){
return String.format("%f + %fi", this.getRealPart(),this.getImaginPart());
}
}

结果截图

实验总结与反思

TDD

伪代码（思路）→ 测试代码（产品预期功能）→ 产品代码（实现预期功能）

总结单元测试的好处

（1）对于整个项目来说，有了完整的测试，保证项目最后交付测试有了可靠依据，减少后期维护的精力和费用
（2）对于开发人员来说大大减少调试工作的时间，同时也规范了对于代码安全管理

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,依赖倒置原则)
（3）能够有效优化代码的设计
（4）测试本身是被测代码的用法说明，替代了一部分代码功能，迫使自己要将被测代码设计得更加独立地去完成某个或某几个功能

OCP实现：

（1）抽象和继承，（2）面向接口编程