源码地址

使用场景

当需要创建复杂对象时，适合使用工厂模式。

4大模块

1. 抽象工厂类，是工厂方法模式的核心；
2. 具体工厂类，实现了具体的业务逻辑；
3. 抽象产品类，是所创建产品的父类；
4. 具体产品类，是实现抽象产品的具体产品对象。

示例

1. 抽象产品类

   public abstract class Product {
       /**
        * 产品类的抽象方法，由具体的产品类实现
        */
       public abstract void method();
   }
   

2. 具体产品类 A

   public class ConcreteProductA extends Product {
       @Override
       public void method() {
           System.out.println("我是具体的产品A");
       }
   }
   

3. 具体产品类 B

   public class ConcreteProductB extends Product {
       @Override
       public void method() {
           System.out.println("我是具体的产品B");
       }
   }
   

4. 抽象工厂类(第一种方式)

   public abstract class Factory {
       /**
        * 抽象工厂方法
        * 具体生产什么由子类实现
        */
       public abstract Product createProduct();
   }
   

5. 具体工厂类(通过 new 的方式创建)

   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   产品对象类类型
        * @return  具体的产品对象
        */
       public abstract <T extends Product> T createProduct(Class<T> clz);
   }
   

8. 具体工厂类(通过反射的方式创建)

   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;
       }
   }
   

简单工厂模式 / 静态工厂模式：去掉抽象工厂类。

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

简单实现

说明：小明的汽车厂需要组装某款车，如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 {
       /**
        * 生产车
        * @param clz   具体型号类型
        * @return  具体型号车对象
        */
       public abstract <T extends AudiCar> T createAudiCar(Class<T> clz);
   }
   

6. 具体生产工厂

   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) {
           //构造一个制造汽车的工厂对象
           AudiFactory factory = new AudiCarFactory();
           //生产 Q3 并启动
           AudiQ3 audiQ3 = factory.createAudiCar(AudiQ3.class);
           audiQ3.drive();
           audiQ3.selfNavigation();
           //生产 Q5 并启动
           AudiQ5 audiQ5 = factory.createAudiCar(AudiQ5.class);
           audiQ5.drive();
           audiQ5.selfNavigation();
           //生产 Q7 并启动
           AudiQ7 audiQ7 = factory.createAudiCar(AudiQ7.class);
           audiQ7.drive();
           audiQ7.selfNavigation();
       }
   }
   

Android 源码中的实现

ArrayList 中创建 Iterator 对象；Activity 中 onCreate 方法 setContentView 创建布局对象。

总结

• 优点

  使用简单，依赖于抽象的架构，扩展性好。

• 缺点

  每次添加新的产品时就要编写一个新的产品类，同时需要引入抽象层，会使得类结构复杂化。