實驗二 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模式，這種先編寫測試代碼，後編寫實驗代碼在一定程度上降低了編寫的錯誤。在實驗中還是感覺自己能力欠缺，還需要努力學習。

20175333曹雅坤 實驗二 Java面向對象程序設計