20175333曹雅坤 实验二 Java面向对象程序设计

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

实验内容

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

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

3. 初步掌握UML建模

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

5. 了解设计模式

根据实验提交的规则，把实验为五个部分

面向对象程序设计-1

单元测试

1.在 IDEA中我们把产品代码放在src目录中，把测试代码放在test目录中，右键单击项目，在弹出的菜单中选择New->Directory新建一个目录：test。

2.再右键点击设置环境变量，选择Mark Directory->Test Sources Root。

3.根据实验内容代码进行测试，分别对“正常情况”、“边界情况”、“异常情况”进行检验 。

面向对象程序设计-2

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

1.这种先写测试代码，然后再写产品代码的开发方法叫“测试驱动开发”（TDD）。

2.TDD的一般步骤如下：

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

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

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

编写产品代码

测试通过

面向对象程序设计-3

对设计模式示例进行扩充，体会OCP原则和DIP原则的应用，初步理解设计模式

用自己的学号%6进行取余运算，根据结果进行代码扩充：

3:让系统支持Long类，并在MyDoc类中添加测试代码表明添加正确.

• 设计模式初步
  
  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,依赖倒置原则) 高层模块不应该依赖于低层模块。二者都应该依赖于抽象,抽象不应该依赖于细节,细节应该依赖于抽象.
  
  模式与设计模式
  
  设计模式有四个基本要素：
  
  Pattern name：描述模式，便于交流，存档
  
  Problem：描述何处应用该模式
  
  Solution：描述一个设计的组成元素，不针对特例
  
  Consequence：应用该模式的结果和权衡（trade-offs)
  
  其他面对对象原则
  
  "组合替代继承":这是说相对于继承，要更倾向于使用组合；
  
  "笛米特法则"：这是说"你的类对其它类知道的越少越好"；
  
  "共同封闭原则"：这是说"相关类应该打包在一起"；
  
  "稳定抽象原则"：这是说"类越稳定，越应该由抽象类组成";

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=1234567890;
    }
    public void DisplayValue()
    {
        System.out.println(value);
    }
}
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 Document
{
    Data pd;
    Document(Factory pf)
    {
        pd = pf.CreateDataObject();
    }
    public void DisplayData()
    {
        pd.DisplayValue();
    }
}
//Test class
public class MyDoc
{
    static Document d;
    static Document e;
    public static void main(String[] args)
    {
        d = new Document(new IntFactory());
        d.DisplayData();
        e=new Document(new LongFactory());
        e.DisplayData();

    }
}

截图

面向对象程序设计-4

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

• 测试代码

import junit.framework.TestCase;
import org.junit.Test;

import static junit.framework.TestCase.assertEquals;

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, Complex.getRealPart(-1.0));
        assertEquals(5.0, Complex.getRealPart(5.0));
        assertEquals(0.0, Complex.getRealPart(0.0));
    }
    @Test
    public void testgetImagePart() throws Exception {
        assertEquals(-1.0, Complex.getImagePart(-1.0));
        assertEquals(5.0, Complex.getImagePart(5.0));
        assertEquals(0.0, Complex.getImagePart(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.ComplexSub(c2).toString());
        assertEquals("-2.0+2.0i", c1.ComplexSub(c3).toString());
        assertEquals("-3.0 -2.0i", c2.ComplexSub(c3).toString());
    }
    @Test
    public void testComplexMulti() throws Exception {
        assertEquals("3.0 -3.0i", c1.ComplexMulti(c2).toString());
        assertEquals("-3.0+6.0i", c1.ComplexMulti(c3).toString());
        assertEquals("-1.0 -3.0i", c2.ComplexMulti(c3).toString());
    }
    @Test
    public void testComplexComplexDiv() throws Exception {
        assertEquals("-1.5 -1.5i", c1.ComplexDiv(c2).toString());
        assertEquals("1.2+0.6i", c1.ComplexDiv(c3).toString());
        assertEquals("-0.6 -0.6i", c2.ComplexDiv(c3).toString());
    }
}

• 产品代码

import java.text.DecimalFormat;//引入DecimalFormat包取一位整数和一位小数

public class Complex {
    double Real=0;
    double Imaginary=0;
    public Complex(){}
    public Complex(double Real,double Imaginary){
        this.Real=Real;
        this.Imaginary=Imaginary;

    }
    public double getReal(){
        return Real;
    }
    public double getImaginary(){
        return Imaginary;
    }
    public String toString(){
        String s = "";
        double r=Real;
        double i=Imaginary;
        if(r==0&&i==0){
            s="0";
        }
        else if(r==0&&i!=0){
            s=i+"i";
        }
        else if(r!=0&&i<0){
            s=r+""+i+"i";
        }
        else if(r!=0&&i==0){
            s=r+"";
        }
        else
        {
            s=r+"+"+i+"i";
        }
        return s;
    }
    public boolean equals(Object obj){//重写equals方法，使其不用来对比字符序列
        if(this==obj){
            return true;
        }
        else
            return false;
    }
    DecimalFormat df = new DecimalFormat( "0.0");
    public Complex ComplexAdd(Complex a){
        return new Complex(Real+a.getReal(),Imaginary+a.getImaginary());
    }
    public Complex ComplexSub(Complex a){
        return new Complex(Real-a.getReal(),Imaginary-a.getImaginary());
    }
    public Complex ComplexMulti(Complex a){
        double r=Real*a.getReal()-Imaginary*a.getImaginary();
        double i =Imaginary*a.getReal()+Real*a.getImaginary();
        return new Complex(Double.valueOf(df.format(r)),Double.valueOf(df.format(i)));
    }
    public Complex ComplexDiv(Complex a){
        double r=(Real * a.Imaginary + Imaginary * a.Real) / (a.Imaginary * a.Imaginary + a.Real * a.Real);
        double i=(Imaginary * a.Imaginary + Real * a.Real) / (a.Real * a.Real + a.Real * a.Real);
        return new Complex(Double.valueOf(df.format(r)),Double.valueOf(df.format(i)));
    }
}

• 截图
  
  

面向对象程序设计-5

• 类图
  
  

实验体会

通过这次实验二，熟悉了代码的编写和添加类，并且对uml类图有了最基本的认识。在实验中还学习了TDD模式，这种先编写测试代码，后编写实验代码在一定程度上降低了编写的错误。在实验中还是感觉自己能力欠缺，还需要努力学习。