瞭解23種設計模式之工廠模式

原創 可乐cc呀 2020-02-21 12:00

一，簡單介紹：

1.1：前言：

古人云：三人行，必有我師焉。

二，簡單的工廠模式

簡單的工廠模式屬於類的創建型模式，又叫靜態工廠方法模式，通過專門定義一個類來負責創建其他類的實例，被創建的實例通常都具有共同的父類， 語句意思也很容易懂。接下來，我們來用最簡單的代碼來實現：

         

  • 工廠（Creator）角色;

            簡單工廠模式的核心，它負責實現創建所有實例的內部邏輯，工廠類可以被外界直接調用，創建所需的產品對象。

  • 抽象（Product） 角色；

            簡單工廠模式所創建的所有對象的父類，它負責描述所有實例所有的公共接口。

  • 具體產品（Concenter Product） 角色；

           簡單工廠模式所創建的具體實例對象

       

     

 2.1: 創建兩個娃娃基類共同實現接口 CqwwCall，創建一個父類使用多態來實現 簡單的工廠模式 ：

  • America  類
  • Japan  類
  • CqwwCall  接口
public class America implements CqwwCall{

    @Override
    public void call(){
        System.out.println("o,yes....o, no, o,yes,o,no");
    }

}
public class Japan implements  CqwwCall{

    @Override
    public void call(){
        System.out.println("o,亞麻跌。。。。。");
    }
}
public interface CqwwCall {

     void  call();
}
  • WawaFactory  類工廠
public class WawaFactory {

    /**
     * 得到美國娃娃的實例
     * @return
     */
    public static CqwwCall getAmericaWawa(){
       return new America();
    }

    /**
     * 得到日本娃娃的實例
     * @return
     */
    public static CqwwCall getJapanWawa(){
        return new Japan();
    }


}
  • 測試
public class TestWawa {

    public static void main(String[] args){
        CqwwCall america =  WawaFactory.getAmericaWawa();
        CqwwCall japan = WawaFactory.getJapanWawa();

        america.call();
        japan.call();
    }
}

 

2.2  這樣的工廠類太簡單了，接下來我們來做升級改造一下工廠類：

  • WawaFactory  工廠類
public class WawaFactory {

   /* *//**
     * 得到美國娃娃的實例
     * @return
     *//*
    public static CqwwCall getAmericaWawa(){
       return new America();
    }

    *//**
     * 得到日本娃娃的實例
     * @return
     *//*
    public static CqwwCall getJapanWawa(){
        return new Japan();
    }*/

    /**
     * 通過傳來的類名來實例化對象
     * @param type
     * @return
     */
    public static CqwwCall getWawa(String type) {
        try {
            //判斷類型
            if(type.equalsIgnoreCase("japan")){
                    return  Japan.class.newInstance();
            }else if(type.equalsIgnoreCase("america")){
                    return  America.class.newInstance();
            }
        } catch (InstantiationException e) {
            e.printStackTrace();
            System.out.println("找不到對象");
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            System.out.println("找不到對象");
        }
        return  null;
    }


}
  • 測試
public class TestWawa {

    public static void main(String[] args){
//        CqwwCall america =  WawaFactory.getAmericaWawa();
//        CqwwCall japan = WawaFactory.getJapanWawa();
//        america.call();
//        japan.call();

        CqwwCall america = WawaFactory.getWawa("america");
        america.call();
        CqwwCall japan = WawaFactory.getWawa("japan");
        japan.call();
    }
}

 

1.2.2 那如果基類太多我們不是要頻繁判斷創建，但是這樣將方法創建變得不太靈活，接下來我們來做繼續升級改造一下工廠類：

public class WawaFactory {

   /* *//**
     * 得到美國娃娃的實例
     * @return
     *//*
    public static CqwwCall getAmericaWawa(){
       return new America();
    }

    *//**
     * 得到日本娃娃的實例
     * @return
     *//*
    public static CqwwCall getJapanWawa(){
        return new Japan();
    }*/

    /**
     * 通過傳來的類名來實例化對象
     * @param type
     * @return
     */
    public static CqwwCall getWawa(String type) {
        try {
            //判斷類型
            if(type.equalsIgnoreCase("japan")){
                    return  Japan.class.newInstance();
            }else if(type.equalsIgnoreCase("america")){
                    return  America.class.newInstance();
            }
        } catch (InstantiationException e) {
            e.printStackTrace();
            System.out.println("找不到對象");
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            System.out.println("找不到對象");
        }
        return  null;
    }

    public static CqwwCall getWawa2(String type) {
        try {
            Class  cqwwCall= Class.forName(type);
            return (CqwwCall)cqwwCall.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            System.out.println("找不到對象");
        }catch (InstantiationException e){
            e.getMessage();
            System.out.println("實例化錯誤");
        }catch (IllegalAccessException e){
            e.getMessage();
            System.out.println("非法訪問異常");
        }
        return  null;
    }
}
  • 測試
public class TestWawa {

    public static void main(String[] args){
//        CqwwCall america =  WawaFactory.getAmericaWawa();
//        CqwwCall japan = WawaFactory.getJapanWawa();
//        america.call();
//        japan.call();

        CqwwCall america = WawaFactory.getWawa2("com.enjoy.cap13.America");
        america.call();
        CqwwCall japan = WawaFactory.getWawa2("com.enjoy.cap13.Japan");
        japan.call();
    }
}

三，工廠方法模式：

工廠方法模式同樣屬於類的創建型模式又被稱爲多態工廠模式。工廠方法模式的意義是定義一個創建產品對象的工廠接口，將實際創建工作推遲到子類當中。核心工廠類不在負責產品的創建，這樣核心類稱爲一個抽象工廠的角色，僅負責具體工廠子類必須實現的接口，這樣進一步抽象化的好處是使得工廠方法模式可以系統在不修改具體工廠角色的情況下引進新的產品。

        

  • 基類    America   Japan (同上簡單工廠方法模式)
  • 接口 CqwwCall   （同上）
  • 創建產品對象的工廠抽象接口 （核心）  WawaInFactory 
public interface WawaInFactory {
      CqwwCall getCawwCall();
}
  • 子類工廠  AmericaFactory ，JapanFactory    去實現創建實例化

 

public class AmericaFactory implements WawaInFactory{
    @Override
    public CqwwCall getCawwCall() {
        return new America();
    }
}
public class JapanFactory implements  WawaInFactory {
    @Override
    public CqwwCall getCawwCall() {
        return  new Japan();
    }
}
  • 測試
public class TestWawa {

    public static void main(String[] args){

        AmericaFactory ambientProperty = new AmericaFactory();
        America america = (America) ambientProperty.getCawwCall();
        america.call();

        JapanFactory japanFactory =new JapanFactory();
        Japan japan = (Japan)japanFactory.getCawwCall();
        japan.call();
    }
}

這樣符合軟件設計開閉原則， 開放讓後面隨意進行擴展，關閉修改以前的代碼。

工廠方法模式比較簡單工廠模式，工廠方法模式與簡單工廠模式在結果上的不同不是很明顯。

  • 工廠方法模式的核心是一個抽象工廠接口類，
  • 簡單工廠模式是把核心放在一個具體類上。

工廠方法模式之所以有一個別名叫多態性工廠模式是因爲具體工廠模式都有共同的接口，或者有共同的抽象方法。

當系統擴展需要添加新的產品對象時僅僅需要添加一個具體對象以及一個具體工廠對象，原有工廠對象不需要進行任何修改，也不需要修改客戶端。

 

四，抽象工廠模式

抽象工廠模式：

抽象工廠模式是所有形態的工廠模式中最爲抽象和最其一般性的，抽象工廠模式可以向客戶端提供一個接口，使得客戶端在不必指定產品具體的情況下，能夠創建多個產品對象。

  • 抽象工廠模式的核心，任何工廠都必須實現這個接口  (CqwwCallFactroy)
  • 具體工廠是抽象工廠的一個實現，負責實例化  （WawaFactroy）
  • 具體產品，抽象模式所創建的具體事例對象  （SpecificJapan, SpencificAmerica）

           

 

public interface CqwwCall {

     void call();
}

 

public abstract class America  implements CqwwCall {

    public abstract void call();

}

public class SpecificAmerica extends America {
    @Override
    public void call() {
        System.out.println("o,yes....o, no, o,yes,o,no");
    }
}
public abstract  class Japan  implements CqwwCall {

     public abstract void call();
}

public class SpecificJapan extends  Japan {
    @Override
   public void call() {
        System.out.println("o,亞麻跌。。。。。");
    }
}
public interface CqwwCallFactroy  {

    /**
     * 創建實例
     * @return
     */
    CqwwCall getAmericaFactory();

    CqwwCall getJapanFactory();
}

public class WawaFactroy implements  CqwwCallFactroy {

    @Override
    public CqwwCall getAmericaFactory() {
        return new SpecificAmerica();
    }

    @Override
    public CqwwCall getJapanFactory() {
        return new SpecificJapan();
    }
}

 

可樂cc呀
發佈了43 篇原創文章 · 獲贊 30 · 訪問量 6萬+
私信 關注
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Android開發 設計模式（二、 Factory Method（工廠方法模式））

SunshineBoy的博客 2020-02-20 15:43:44

Android開發 設計模式（二、 Factory Method（工廠方法模式））

SunshineBoy的博客 2020-02-20 15:43:44