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