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

实验内容

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

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

3. 初步掌握UML建模

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

5. 了解设计模式

实验步骤

单元测试

• 三种代码

  • 伪代码：使用自然语言来显示设计步骤，有助于对整个设计模块有个清晰的认识，例如老师给的这个例子（不涉及到任何程序语言）

   百分制转五分制：
   如果成绩小于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!");
      }
  }
  

  1）正常情况检验

  1. 测试值为50
     

  2. 全面测试
     

  2）异常情况检验

  1. 测试非正常数值

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

  

  原因是未对负分进行检测，因此要在原代码的基础上加上对负分的判断

      //如果成绩小于0，转成“错误”
     if ((grade < 0))
         return "错误";
  

  2. 对边界值进行测试

  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 "优秀";
  
  

• TDD测试

  • 一般步骤

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

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

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

    4. 编写产品代码

    5. 测试通过

    6. 对代码进行重构，并保证测试通过

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

  • IDEA下使用TDD

  

  

• TDD的编码节奏是

1. 增加测试代码，JUnit出现红条

2. 修改产品代码

3. JUnit出现绿条，任务完成

参考资料

1. 单元测试之道
2. Agile Java 中文版

面向对象三要素

• 抽象

  抽出事物的本质特征而暂时不考虑他们的细节。对于复杂系统问题人们借助分层次抽象的方法进行问题求解；

  在抽象的最高层，可以使用问题环境的语言，以概括的方式叙述问题的解。

  在抽象的较低层，则采用过程化的方式进行描述。在描述问题解时，使用面向问题和面向实现的术语。

  程序设计中，抽象包括两个方面，一是过程抽象，二是数据抽象。

• 封装、继承与多态

  • 面向对象的思想涉及到软件开发的各个方面，如面向对象分析（OOA）、面向对象设计（OOD）、面向对象编程实现(OOP)

  • OOA根据抽象关键的问题域来分解系统，关注是什么

  • OOD是一种提供符号设计系统的面向对象的实现过程，用非常接近问题域术语的方法把系统构造成“现实世界”的对象，关注怎么做（how）,通过模型来实现功能规范

  • OOP则在设计的基础上用编程语言（如Java）编码。贯穿OOA、OOD和OOP的主线正是抽象。

  • 封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度,从而带来模块化和信息隐藏的好处；

  • 接口是封装的准确描述手段。

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

  • 教程例子：

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

UML操作具体参考资料

设计模式

• S.O.L.I.D 原则

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

  对象提供单一职责的高度封装，对象的改变仅仅依赖于单一职责的改变，它基于软件设计中的高内聚性定义

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

    OCP可以用以下手段实现：（1）抽象和继承，（2）面向接口编程。

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

    1. 子类必须可以被其基类所代
    2. 使用指向基类的指针或引用的函数，必须能够在不知道具体派生类对象类型的情况下使用它
    3. 核心思想是父类型对象可以被子类型对象所取代

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

    客户不应该依赖他们并未使用的接口

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

    1. 高层模块不应该依赖于低层模块。二者都应该依赖于抽象
    2. 抽象不应该依赖于细节。细节应该依赖于抽象

• 模式与设计模式

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

• 设计模式实示例

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

扩展示例：支持Long类

    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 {
        int value;
        Long() {
            value=100000;
        }
        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();
        }
    }
    
    //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 LongFactory());
            d.DisplayData();
        }
    }
    

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

伪代码：

Complex类要输出实部和虚部，并以a+bi的形式进行输出
Complex类中有两个变量，实部a和虚部b

方法：
getA(int a);返回实部
getB(int b);返回虚部
ComplexAdd(Complex c);加法
ComplexMinus(Complex c);减法
ComplexMulti(Complex c);乘法
toString(double a,double b);以a+bi格式进行输出

产品代码：

public class Complex {    //a + bi
    private double a;
    private double b;

    public Complex(){                      //构造方法，置0
         this.a = 0;
         this.b = 0;
    }

    public Complex(double a, double b) {  //构造方法，初始化一个复数
        this.a = a;
        this.b = b;
    }

    public  double getA(){                  //获取实部
        return this.a;
    }
    public double getB(){                  //获取虚部
        return this.b;
    }

    public double setA(double a){         //设置实部
       this.a = a;
        return a;
    }
    public double setB(double b){         //设置虚部
        this.b = b;
        return b;
    }

    Complex ComplexAdd(Complex c){//复数相加
        double a = c.getA();
        double b = c.getB();
        double newA = a + this.a;
        double newB = b + this.b;
        Complex Result = new Complex(newA,newB);
        return Result;
    }

    Complex ComplexMinus(Complex c){//复数相减
        double a = c.getA();
        double b = c.getB();
        double newA = a - this.a;
        double newB = b - this.b;
        Complex Result = new Complex(newA,newB);
        return Result;
    }

    Complex ComplexMulti(Complex c){//复数相乘
        double a = c.getA();
        double b = c.getB();
        double newA = a * this.a;
        double newB = b * this.b;
        Complex Result = new Complex(newA,newB);
        return Result;
    }

    Complex ComplexDiv(Complex c){//复数相乘
        double a = c.getA();
        double b = c.getB();
        double newA = a / this.a;
        double newB = b / this.b;
        Complex Result = new Complex(newA,newB);
        return Result;
    }

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

测试代码：

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

    public class ComplexTest extends TestCase {
        Complex c1 = new Complex(0, 3);
        Complex c2 = new Complex(-1, -1);
        Complex c3 = new Complex(2,1);
        @Test
        public void testgetRealPart() throws Exception {
            assertEquals(-1.0, new Complex().setA(-1.0));
            assertEquals(5.0, new Complex().setA(5.0));
            assertEquals(0.0, new Complex().setA(0.0));
        }
        @Test
        public void testgetImagePart() throws Exception {
            assertEquals(-1.0, new Complex().setB(-1.0));
            assertEquals(5.0, new Complex().setB(5.0));
            assertEquals(0.0, new Complex().setB(0.0));
        }
        @Test
        public void testComplexAdd() throws Exception {
            assertEquals("-1.0+2.0i", c1.ComplexAdd(c2).toString());
            assertEquals("2.0+4.0i", c1.ComplexAdd(c3).toString());
            assertEquals("1.0", c2.ComplexAdd(c3).toString());
        }
        @Test
        public void testComplexSub() throws Exception {
            assertEquals("-1.0 -4.0i", c1.ComplexMinus(c2).toString());
            assertEquals("2.0 -2.0i", c1.ComplexMinus(c3).toString());
            assertEquals("3.0+2.0i", c2.ComplexMinus(c3).toString());
        }
        @Test
        public void testComplexMulti() throws Exception {
            assertEquals("-0.0 -3.0i", c1.ComplexMulti(c2).toString());
            assertEquals("0.0+3.0i", c1.ComplexMulti(c3).toString());
            assertEquals("-2.0 -1.0i", c2.ComplexMulti(c3).toString());
        }
        @Test
        public void testComplexComplexDiv() throws Exception {
            assertEquals("-0.0 -3.0i", c2.ComplexDiv(c1).toString());
            assertEquals("-0.0 -3.0i", c2.ComplexDiv(c1).toString());
            assertEquals("-2.0 -1.0i", c2.ComplexDiv(c3).toString());
        }
    }

PSP(Personal Software Process)时间

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

总结

本次实验的内容总的来说还是不少的，除了了解到设计模式之外，还学会使用了UML构图，并将图转化为Java代码，感觉还是不容易的。对于单元测试我觉得对于代码的健壮性而言还是很有必要的，在设计的阶段就主动地去发现问题并完善代码可以减少代码中显式或隐式的bug，在不断测试的过程中，自己考虑问题也就更加详细。