設計模式(二) 工廠模式

Hello

回顧: 面向對象設計的基本原則

1.OCP(開閉原則): 一個應用的實體對擴展開放,對修改關閉.(白話: 如今我有兩個類構建一個功能,若是想要擴展新功能的話,根據原則是不要在原有的兩個類上作修改,從新新建一個類來完成新加的功能)

2.DIP(依賴反轉原則): 要針對接口編程,不要針對實現編程(白話: A實現類調用B實現類,具體關係,根據原則B類應當實現接口C類,而後A類與C類發生關係,將具體關係轉爲抽象依賴)

3.LoD(迪米特法則): 只與朋友通訊.(白話: 該法則的初衷在於下降對象之間的耦合,減小類和類的直接關係,功能的複用,模塊獨立化...更多信息[百度,gooale]查閱)

附加: 耦合類型,由高到低 ↓↓↓

• 內容耦合: 當一個模塊直接修改或操做另外一個模塊的數據時,或一個模塊不經過正常入口而轉入另外一個模塊時,該耦合是最高程度的耦合,應該避免使用之
• 公共耦合: 兩個及以上的模塊共同引用一個全局數據項爲公共耦合
• 外部耦合: 一組模塊都訪問同一全局簡單變量而不是同一全局數據結構,並且不是經過參數表傳遞該全局變量的信息,爲外部耦合
• 控制耦合: 一個模塊經過接口向另外一個模塊傳遞一個控制信號,接受信號的模塊根據信號值而進行適當的動做,爲控制耦合
• 標記耦合: 若一個模塊A經過接口向兩個模塊B和C傳遞一個公共參數,那麼稱模塊B和C之間存在一個標記耦合
• 數據耦合: 模塊之間經過參數來傳遞數據,爲數據耦合.數據耦合是最低的一種耦合形式,系統中都存在這種類型的耦合,由於爲了完成一些有意義的功能,每每須要將某些模塊的輸出數據做爲另外一些模塊的輸入數據
• 非直接耦合: 兩個模塊之間沒有直接關係,它們之間的聯繫徹底是經過主模塊的控制和調用來實現的

工廠模式

實現建立和調用的分離, 將選擇實現類、建立對象統一管理和控制.

三種工廠模式:

簡單工廠

建立同一結構類型的任何對象,對於新增的對象,須要修改已有代碼

建立一個接口Dog

public interface Dog {
    void ability();
}

建立三種Dog,直接上真名了

public class 中華田園犬 implements Dog {
    @Override
    public void ability() {
        System.out.println("中華田園犬: 什麼都能吃,聽話,好養,能力強");
    }
}

public class 哈士奇 implements Dog {
    @Override
    public void ability() {
        System.out.println("哈士奇: 吃葷吃素還不知道,這種狗的能力你們都知道");
    }
}

public class 哈巴狗 implements Dog {
    @Override
    public void ability() {
        System.out.println("哈巴狗: 大眼憨厚,聽話好使");
    }
}

建立工廠類

public class FactoryZone {
    //第一種方式
    public static Dog factoryForDog(String type){
        Dog dog=null;
        if (type.equals("中華田園犬")){
            dog=new 中華田園犬();
        }else if (type.equals("哈士奇")){
            dog=new 哈士奇();
        }else if (type.equals("哈巴狗")){
            dog=new 哈巴狗();
        }
        //新增的話,須要在此處追加.
        return dog;
    }

    //第二種方式
    public Dog get中華田園犬(){
        return new 中華田園犬();
    }
    public Dog get哈士奇(){
        return new 哈士奇();
    }
    public Dog get哈巴狗(){
        return new 哈巴狗();
    }
}

測試 FactoryMain

public class FactoryMain {
    public static void main(String[] args) {
        //無工廠模式,這種狀況下FactoryMain依賴Dog接口以及中華田園犬類,哈士奇類,哈巴狗類
        Dog dog=new 中華田園犬();
        dog.ability();
        Dog dog1=new 哈士奇();
        dog1.ability();
        Dog dog2=new 哈巴狗();
        dog2.ability();

        //簡單工廠模式,這種狀況下FactoryMain依賴FactoryZone以及Dog接口
        //內部FactoryZone依賴Dog接口以及中華田園犬類,哈士奇類,哈巴狗類
        //總體關係複雜,調用者簡單
        FactoryZone.factoryForDog("中華田園犬").ability();
        FactoryZone.factoryForDog("哈士奇").ability();
        FactoryZone.factoryForDog("哈巴狗").ability();
    }
}

工廠方法

建立同一結構類型的固定對象,能夠新增任何對象

建立 DogFactory接口

public interface DogFactory {
    Dog getDog();
}

建立不一樣的生產工廠

public class 中華田園犬Factory implements DogFactory {
    @Override
    public Dog getDog() {
        return new 中華田園犬();
    }
}

public class 哈士奇Factory implements DogFactory {
    @Override
    public Dog getDog() {
        return new 哈士奇();
    }
}

public class 哈巴狗Factory implements DogFactory {
    @Override
    public Dog getDog() {
        return new 哈巴狗();
    }
}
若是新增了其餘的Dog的時候,須要新增另外的類xxFactory implements DogFactory
該設計符合開閉原則,若是不少Dog的話,就也要加不少的xxFactory類

public class FactoryMain {
    public static void main(String[] args) {
        //工廠方式模式,FactoryMain依賴DogFactory以及中華田園犬Factory(),哈士奇Factory(),哈巴狗Factory()
        //DogFactory依賴Dog接口以及中華田園犬類,哈士奇類,哈巴狗類
        DogFactory dogFactory = new 中華田園犬Factory();
        dogFactory.getDog().ability();
        DogFactory dogFactory1 = new 哈士奇Factory();
        dogFactory1.getDog().ability();
        DogFactory dogFactory2 = new 哈巴狗Factory();
        dogFactory2.getDog().ability();
    }
}

理論和實際老是相差些什麼,正常狀況下,仍是使用簡單工廠會多點.

抽象工廠

建立不一樣產品族的任何對象,不能夠新增新單個對象,能夠新增不一樣產品族,用到這種模式說明項目體系比較大了,引用某大大的一張圖作記錄,該模式是工廠的工廠,根據下圖創建理解思惟,代碼省略:

 

-----------------------------------------------------------