2016-2017-2 20155326实验二《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，我们不会出现过度设计的情况，需求通过测试用例表达出来了，我们的产品代码只要让测试通过就可以了。

基本了解完TDD后开始进行实验，实验结果如下图所示：

（三）面向对象三要素：封装、继承、多态

（1）抽象

抽象一词的本意是指人在认识思维活动中对事物表象因素的舍弃和对本质因素的抽取。抽象是人类认识复杂事物和现象时经常使用的思维工具，抽象思维能力在程序设计中非常重要，"去粗取精、化繁为简、由表及里、异中求同"的抽象能力很大程度上决定了程序员的程序设计能力。

抽象就是抽出事物的本质特征而暂时不考虑他们的细节。对于复杂系统问题人们借助分层次抽象的方法进行问题求解；在抽象的最高层，可以使用问题环境的语言，以概括的方式叙述问题的解。在抽象的较低层，则采用过程化的方式进行描述。在描述问题解时，使用面向问题和面向实现的术语。

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

我们举个例子说明一下。比如有了以下Java代码：



System.out.println(1);

System.out.println(2);

System.out.println(3);

可以打印出“1,2,3”，想打引“1,2,3,4”怎么办？同学们的做法大多是把上面的代码拷贝下来，再加一行：



System.out.println(1);

System.out.println(2);

System.out.println(3);

System.out.println(4);

这就是没有学会过程抽象的做法“拷贝粘贴”式开发。解决问题没？解决了，但有问题，比如想打印出“1..100"怎么办？粘贴100行？这两段代码有三行重复的代码，违反了常见的一个编程原则DRY(Don't Repeat Yourself)，解决的方法是进行过程抽象，写一个函数printn：



public void printn(int n){

    for(int i=1;  i<=n; i++)

        System.out.println(n);

}

上面两段代码就可以用;



printn(3);

printn(4);

代替了，打印出“1..100"也很简单，只要调用printn(100);就行了。

面向对象(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）是封装的准确描述手段。



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 ResponsibilityPrinciple,单一职责原则)

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

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

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

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

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

设计模式实例

让系统支持Boolen类

代码如下：



abstract class Data{

    public abstract void DisplayValue();

}

class Integer extends Data {

    int value;

    Integer(){

        value=100;

    }

    public void DisplayValue(){

        System.out.println(value);

    }

}

class Boolean extends Data{

    boolean value;

    Boolean(){

        value=false;

    }

    public void DisplayValue(){

        if(value)

        {

            System.out.println("20155326true");

        }

        else {

            System.out.println("20155326false");

        }

    }

}

class Document {

    Data pd;

    Document() {

        pd=new Boolean();

    }

    public void DisplayData(){

        pd.DisplayValue();

    }

}

public class MyDoc {

    static Document d;

    public static void main(String[] args) {

        d = new Document();

        d.DisplayData();

    }

}

运行结果：

练习

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

伪代码

Complex类

定义实部以及虚部；

方法Set设置实部,以及虚部：public double setRealPart()，public double setImagePart();

方法Get取得实部，以及虚部：public double getRealPart()，public double getImagePart();

方法加法Complex ComplexAdd(Complex a)

方法减法Complex ComplexSub(Complex a)

方法乘法Complex ComplexMultib(Complex a)

方法除法Complex ComplexDiv(Complex a)

方法toString()控制输出格式

产品代码



import java.util.Scanner;

public class Complex {

    static int r;

    static int i;

    private double a;

    private double b;

    public static int getRealPart(int RealPart){

            r = RealPart;

        return r;

    }

    public static int getImaginePart(int ImaginePart){

            i = ImaginePart;

        return i;

    }

    public Complex(double a, double b) {

        this.a = a;

        this.b = b;

    }

    public Complex add(Complex c) {

        return new Complex(a + c.a, b + c.b);

    }

    public Complex minus(Complex c) {

        return new Complex(a - c.a, b - c.b);

    }

    public Complex multiply(Complex c) {

        return new Complex(a * c.a - b * c.b, a * c.b + b * c.a);

    }

    public String toString() {

        String rtr_str = "";

        if (a > 0)

            rtr_str = "(" + a + "+" + b + "i" + ")";

        if (b == 0)

            rtr_str = "(" + a + ")";

        if (b < 0)

            rtr_str = "(" + a + b + "i" + ")";

        return rtr_str;

    }

}

测试代码



import junit.framework.TestCase;

import org.junit.Test;

import static org.junit.Assert.*;

public class ComplexTest extends TestCase {

        Complex a=new Complex(1,2);

        Complex d=new Complex(0,-1);

        Complex e=new Complex(0,0);

        @Test

        public void testgetRealPart() throws Exception {

            assertEquals(1, Complex.getRealPart(1));

            assertEquals(-1, Complex.getRealPart(-1));

            assertEquals(0, Complex.getRealPart(0));

        }

        @Test

        public void testgetImaginePart() throws Exception {

            assertEquals(1, Complex.getImaginePart(1));

            assertEquals(-1, Complex.getImaginePart(-1));

            assertEquals(2, Complex.getImaginePart(2));

            assertEquals(0, Complex.getImaginePart(0));

        }

        @Test

        public void testadd() throws Exception {

            assertEquals("(1.0-1.0i)", a.add(d).toString());

            assertEquals("(1.0+2.0i)", a.add(e).toString());

        }

        @Test

        public void testminus() throws Exception {

            assertEquals("(1.0+5.0i)", a.minus(b).toString());

            assertEquals("(1.0+2.0i)", a.minus(c).toString());

        }

        @Test

        public void testmultiply() throws Exception {

            assertEquals("(9.0-2.0i)", a.multiply(b).toString());

            assertEquals("(19.0-38.0i)", a.multiply(b).toString());

            assertEquals("(6.0-3.0i)", a.multiply(b).toString());

            assertEquals("(0.0)", a.multiply(e).toString());

        }

    }