2016-2017-2 20155117实验二《Java面向对象程序设计》实验报告

实验内容

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

实验要求

• 1.参考Intellj IDEA 简易教程
  
  提交最后三个测试用例都通过的截图，截图上要有画图加水印，输入自己的学号。
• 2.参考 积极主动敲代码使用JUnit学习Java,以 TDD的方式研究学习StringBuffer，提交你的单元测试用例和测试通过的截图，截图要加上学号水印。
• 3.实验二 Java面向对象程序设计
  
  对设计模式示例进行扩充，体会OCP原则和DIP原则的应用，初步理解设计模式用自己的学号%6进行取余
  
  运算，根据结果进行代码扩充：
  
  让系统支持Boolean类，并在MyDoc类中添加测试代码表明添加正确
• 4.以TDD的方式开发一个复数类Complex支持加减乘除。
• 5.使用StarUML对实验二中的代码进行建模，发类图的截图，加上学号水印。类图中至少两个类。

实验步骤

（一）单元测试

编程是智力活动，不是打字，编程前要把干什么、如何干想清楚才能把程序写对、写好。所以当想用程序解决问题时，要会写三种码：伪代码、产品代码、测试代码。

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

TDD的一般步骤如下：

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

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

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

编写产品代码

测试通过

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

循环完成所有功能的开发

基于TDD，我们不会出现过度设计的情况，需求通过测试用例表达出来了，我们的产品代码只要让测试通过就可以了。

面向对象(Object-Oriented)的三要素包括：封装、继承、多态。

面向对象的思想涉及到软件开发的各个方面，如面向对象分析（OOA）、面向对象设计（OOD）、面向对象编程实现(OOP)。OOA根据抽象关键的问题域来分解系统，关注是什么（what）。OOD是一种提供符号设计系统的面向对象的实现过程，用非常接近问题域术语的方法把系统构造成“现实世界”的对象，关注怎么做（how）,通过模型来实现功能规范。OOP则在设计的基础上用编程语言（如Java）编码。贯穿OOA、OOD和OOP的主线正是抽象。

OOD中建模会用图形化的建模语言UML（Unified Modeling Language）,UML是一种通用的建模语言，我们实验中使用umbrello进行建模，Windows中推荐大家使用 StarUML。

过程抽象的结果是函数，数据抽象的结果是抽象数据类型（Abstract Data Type，ADT），类可以作具有继承和多态机制的ADT。数据抽象才是OOP的核心和起源。

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

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

使用starUML

S.O.L.I.D原则

SRP(Single ResponsibilityPrinciple,单一职责原则)

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

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

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

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

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

让系统支持Double类

设计模式实例

package exp2;
    // Server Classes
    abstract class Data {
        abstract public void DisplayValue();
    }
    class Integer extends  Data {
        int value;
        Integer() {
            value=100;
        }
        public void DisplayValue(){
            System.out.println (value);
        }
    }
    class Double extends  Data {
        double value;
        Double() {
            value=8.345;
        }
        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 DoubleFactory extends Factory {
        public Data CreateDataObject(){
            return new Double();
        }
    }
    //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 DoubleFactory());
            d.DisplayData();
        }
    }

设计Complex。

产品代码

package exp2;

import java.util.Scanner;
import java.lang.String;

public class Complex {
    private double a;
    private double b;

    public Complex(){
        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 new_a = a + this.a;
        double new_b = b + this.b;
        return new Complex(new_a, new_b);
    }

    Complex ComplexMinus(Complex c){
        double a = c.getA();
        double b = c.getB();
        double new_a = a - this.a;
        double new_b = b - this.b;
        return new Complex(new_a, new_b);
    }

    Complex ComplexMulti(Complex c){
        double a = c.getA();
        double b = c.getB();
        double new_a = a * this.a;
        double new_b = b * this.b;
        return new Complex(new_a, new_b);
    }
    Complex ComplexDiv(Complex c){
        double a = c.getA();
        double b = c.getB();
        double new_a = (a * c.b + b *c.a) / (c.b * c.b + c.a * c.a);
        double new_b = (b * c.b + a * c.a) / (c.b * c.b + c.a * c.a);
        return new Complex(new_a, new_b);
    }

    public String toString(double a,double b){
        String cnum = " ";
        if(b == 0) {
            cnum = "" + a;
        }
        else if(b < 0) {
            cnum = a + b + "i";
        }
        else if(b > 0){
            cnum = a + "+" + b +"i";
        }
        return cnum;
    }
}

测试代码

package exp2;
import static org.junit.Assert.*;
import org.junit.Test;

public class ComplexTest {
    @Test
    public void Complex(){

        Complex num1 = new Complex();
        assert num1.getA() == 0 : "error1:Complex()";
        assert num1.getA() == 0 : "error2:Complex()";

        Complex num2 = new Complex(0, 0);
        assert num2.getA() == 0 : "error3:Complex(double a,double b)";
        assert num2.getB() == 0 : "error4:Complex(double a,double b)";

        Complex num3 = new Complex();
        num3.setA(0);
        assert num3.getA() == 0 : "error7:setA(double a)";

        num3.setB(0);
        assert num3.getB() == 0 : "error8:setB(double b)";

        Complex num4 = new Complex();
        Complex num5 = new Complex(-1, -1);
        Complex num6 = new Complex();
        num4 = num1.ComplexAdd(num1);
        assert num4.getA() == 0 : "error9:ComplexAdd(Complex c)";
        assert num4.getB() == 0 : "error10:ComplexAdd(Complex c)";
        num6 = num1.ComplexAdd(num5);
        assert num6.getA() == -1 : "error11:ComplexAdd(Complex c)";
        assert num6.getB() == -1 : "error12:ComplexAdd(Complex c)";

        Complex num7 = new Complex();
        Complex num8 = new Complex(1, 1);
        Complex num9 = new Complex();
        num7 = num1.ComplexMinus(num1);
        assert num7.getA() == 0 : "error13:ComplexMinus(Complex c)";
        assert num7.getB() == 0 : "error14:ComplexMinus(Complex c)";
        num9 = num1.ComplexMinus(num8);
        assert num9.getA() == 1 : "error13:ComplexMinus(Complex c)";
        assert num9.getB() == 1 : "error14:ComplexMinus(Complex c)";

        Complex num10 = new Complex();
        Complex num11 = new Complex(-1, -1);
        Complex num12 = new Complex();
        Complex num13 = new Complex();
        Complex num14 = new Complex(1, 1);
        num10 = num1.ComplexMulti(num1);
        assert num10.getA() == 0 : "error15:ComplexMulti(Complex c)";
        assert num10.getB() == 0 : "error16:ComplexMulti(Complex c)";
        num12 = num1.ComplexMulti(num11);
        assert num12.getA() == 0 : "error17:ComplexMulti(Complex c)";
        assert num12.getB() == 0 : "error18:ComplexMulti(Complex c)";
        num13 = num11.ComplexMulti(num14);
        assert num13.getA() == -1 : "error19:ComplexMulti(Complex c)";
        assert num13.getB() == -1 : "error20:ComplexMulti(Complex c)";

        System.out.println("Pass!");
    }
}