源碼地址

使用場景

當(dāng)需要創(chuàng)建復(fù)雜對象時办陷，適合使用工廠模式。

4大模塊

1. 抽象工廠類炸枣，是工廠方法模式的核心虏等；
2. 具體工廠類，實現(xiàn)了具體的業(yè)務(wù)邏輯适肠；
3. 抽象產(chǎn)品類霍衫，是所創(chuàng)建產(chǎn)品的父類；
4. 具體產(chǎn)品類侯养，是實現(xiàn)抽象產(chǎn)品的具體產(chǎn)品對象敦跌。

示例

1. 抽象產(chǎn)品類

   public abstract class Product {
       /**
        * 產(chǎn)品類的抽象方法，由具體的產(chǎn)品類實現(xiàn)
        */
       public abstract void method();
   }
   

2. 具體產(chǎn)品類 A

   public class ConcreteProductA extends Product {
       @Override
       public void method() {
           System.out.println("我是具體的產(chǎn)品A");
       }
   }
   

3. 具體產(chǎn)品類 B

   public class ConcreteProductB extends Product {
       @Override
       public void method() {
           System.out.println("我是具體的產(chǎn)品B");
       }
   }
   

4. 抽象工廠類(第一種方式)

   public abstract class Factory {
       /**
        * 抽象工廠方法
        * 具體生產(chǎn)什么由子類實現(xiàn)
        */
       public abstract Product createProduct();
   }
   

5. 具體工廠類(通過 new 的方式創(chuàng)建)

   public class ConcreteFactory extends Factory {
       @Override
       public Product createProduct() {
           return new ConcreteProductA();
   //        return new ConcreteProductB();
       }
   }
   

6. 客戶類

   public class Client {
       public static void main(String[] args) {
           Factory factory = new ConcreteFactory();
           Product product = factory.createProduct();
           product.method();
   
           //Factory2 factory2 = new ConcreteFactory2();
           //ConcreteProductB product2 = factory2.createProduct(ConcreteProductB.class);
           //product2.method();
       }
   }
   

7. 抽象工廠類(第二種方式)

   public abstract class Factory2 {
       /**
        * 抽象工廠方法
        * @param clz   產(chǎn)品對象類類型
        * @return  具體的產(chǎn)品對象
        */
       public abstract <T extends Product> T createProduct(Class<T> clz);
   }
   

8. 具體工廠類(通過反射的方式創(chuàng)建)

   public class ConcreteFactory2 extends Factory2 {
       @Override
       public <T extends Product> T createProduct(Class<T> clz) {
           Product product = null;
           try {
               product = ((Product) Class.forName(clz.getName()).newInstance());
           } catch (Exception e) {
               e.printStackTrace();
           }
           return (T) product;
       }
   }
   

簡單工廠模式 / 靜態(tài)工廠模式：去掉抽象工廠類沸毁。

public class Factory {
    public static Product createProduct() {
        return new ConcreteProductA()
        //return new ConcreteProductB()
    }
}

簡單實現(xiàn)

說明：小明的汽車廠需要組裝某款車峰髓，如Q3傻寂、Q5、Q7携兵，具體代碼如下：

1. 抽象車型

   public abstract class AudiCar {
       /**
        * 汽車啟動
        */
       public abstract void drive();
   
       /**
        * 汽車自動巡航
        */
       public abstract void selfNavigation();
   }
   

2. 具體車型 Q3

   public class AudiQ3 extends AudiCar {
       @Override
       public void drive() {
           System.out.println(" Q3 起飛~~~ ");
       }
   
       @Override
       public void selfNavigation() {
           System.out.println(" Q3 開始自動巡航~~~ ");
       }
   }
   

3. 具體車型 Q5

   public class AudiQ5 extends AudiCar {
       @Override
       public void drive() {
           System.out.println(" Q5 起飛~~~ ");
       }
   
       @Override
       public void selfNavigation() {
           System.out.println(" Q5 開始自動巡航~~~ ");
       }
   }
   

4. 具體車型 Q7

   public class AudiQ7 extends AudiCar {
       @Override
       public void drive() {
           System.out.println(" Q7 起飛~~~ ");
       }
   
       @Override
       public void selfNavigation() {
           System.out.println(" Q7 開始自動巡航~~~ ");
       }
   }
   

5. 抽象工廠

   public abstract class AudiFactory {
       /**
        * 生產(chǎn)車
        * @param clz   具體型號類型
        * @return  具體型號車對象
        */
       public abstract <T extends AudiCar> T createAudiCar(Class<T> clz);
   }
   

6. 具體生產(chǎn)工廠

   public class AudiCarFactory extends AudiFactory {
       @Override
       public <T extends AudiCar> T createAudiCar(Class<T> clz) {
           AudiCar car = null;
           try {
               car = ((AudiCar) Class.forName(clz.getName()).newInstance());
           } catch (Exception e) {
               e.printStackTrace();
           }
           return (T) car;
       }
   }
   

7. 流水線（客戶類）

   public class Client {
       public static void main(String[] args) {
           //構(gòu)造一個制造汽車的工廠對象
           AudiFactory factory = new AudiCarFactory();
           //生產(chǎn) Q3 并啟動
           AudiQ3 audiQ3 = factory.createAudiCar(AudiQ3.class);
           audiQ3.drive();
           audiQ3.selfNavigation();
           //生產(chǎn) Q5 并啟動
           AudiQ5 audiQ5 = factory.createAudiCar(AudiQ5.class);
           audiQ5.drive();
           audiQ5.selfNavigation();
           //生產(chǎn) Q7 并啟動
           AudiQ7 audiQ7 = factory.createAudiCar(AudiQ7.class);
           audiQ7.drive();
           audiQ7.selfNavigation();
       }
   }
   

Android 源碼中的實現(xiàn)

ArrayList 中創(chuàng)建 Iterator 對象疾掰；Activity 中 onCreate 方法 setContentView 創(chuàng)建布局對象。

總結(jié)

• 優(yōu)點

  使用簡單徐紧，依賴于抽象的架構(gòu)静檬，擴展性好。

• 缺點

  每次添加新的產(chǎn)品時就要編寫一個新的產(chǎn)品類并级，同時需要引入抽象層拂檩，會使得類結(jié)構(gòu)復(fù)雜化。