工厂模式（Factory Pattern）

一、工厂模式（Factory Pattern）的介绍

　　工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。使用工厂模式可能会多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。

二、工厂模式的分类

　　1.简单工厂模式

　　2.工厂方法模式

　　3.抽象工厂模式

三、简单工厂模式

　　1.父类产品

 /**
  * 父类产品
  */
 public class Product {
     public Product(){
         System.out.println("------product------");
     }
     public void change(){
         System.out.println("-----父类方法------");
     }
 }

·　　2. A B C 三种子类产品

 //子类产品A
 public class ProductA extends Product {
     public ProductA() {
         System.out.println("------产品A------");
     }
     @Override
     public void change() {
         System.out.println("------方法A------");
     }
 }

 //子类产品B
 public class ProductB extends Product {
     public ProductB() {
         System.out.println("------产品B------");
     }

     @Override
     public void change() {
         System.out.println("------方法B------");
     }
 }

 //子类产品C
 public class ProductC extends Product {
     public ProductC() {
         System.out.println("------产品C------");
     }

     @Override
     public void change() {
         System.out.println("------方法C------");
     }
 }

　　3、创建产品的工厂类

　　工厂类是整个模式的关键，包含了必要的逻辑判断，根据外界给定的信息，决定究竟应该创建哪个具体类的对象。

 /**
  * 创建产品的工厂
  */
 public class Factory {

     /**
      * 静态方法,直接调用
      * 自动向上转型,转为product
      */
     public static Product createProduct(String param){
         if (param.equals("A")){
             Product productA = new ProductA();
             return productA;
         }else if (param.equals("B")){
             Product productB = new ProductB();
             return productB;
         }else if (param.equals("C")){
             ProductC productC = new ProductC();
             return productC;
         }
         return new Product();
     }

     public static void change(Product product){
         product.change();
     }
 }

　　4、比较普通创建对象的方法和测试简单工厂方法

 public class TestProduct {
     @Test
     public void test1(){
         /**
          * 没有工厂模式
          * 每个产品都需要创建
          */
         ProductA productA = new ProductA();
         ProductB productB = new ProductB();
         ProductC productC = new ProductC();
         System.out.println("------productA------" + productA);
         System.out.println("------productB------" + productB);
         System.out.println("------productC------" + productC);
     }

     @Test
     public void test2(){
         /**
          * 工厂设计
          * 参数不同,返回产品不同
          * 向下转型,和本身的类型相关
          */
         ProductA productA = (ProductA) Factory.createProduct("A");
         ProductB productB = (ProductB) Factory.createProduct("B");
         ProductC productC = (ProductC) Factory.createProduct("C");
         System.out.println("------productA------" + productA);
         System.out.println("------productB------" + productB);
         System.out.println("------productC------" + productC);
         // 多态测试
         Factory.change(productA);
         Factory.change(productB);
         Factory.change(productC);
     }
 }

　　5.小结简单工厂

　　简单工厂的所有产品都是在一个工厂生产的，通过在构造时判断传入的参数不同来生产不同的产品，这种模式会随着产品的增加而越来越庞大，每次新增产品都要添加修改判断条件，即修改工厂类，给维护和扩展带来不便。并且一但工厂类中出错，所有产品都无法创建了。

四、工厂方法模式

　　1.抽象产品工厂类

　　工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

 /**
  * 抽象产品工厂类
  * Product为抽象产品
  */
 public abstract class Factory {
     abstract Product create();
 }

　　2.具体的A、B工厂类

　　2个工厂都继承抽象工厂类，它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。

 /**
  * A工厂生产A产品
  */
 public class AFactory extends Factory {
     @Override
     public Product create() {
         return new ProductA();
     }
 }

 /**
  * B工厂生产B产品
  */
 public class BFactory extends Factory {
     @Override
     Product create() {
         return new ProductB();
     }
 }

　　3.抽象产品接口

　　它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。

 /**
  * 抽象产品接口
  */
 public interface Product {
     void method();
 }

　　4.具体产品类

　　A、B 产品都实现抽象产品接口

 /**
  * 具体产品A
  */
 public class ProductA implements Product{
     @Override
     public void method() {
         System.out.println("------ProductA------");
     }
 }

 /**
  * 具体产品B
  */
 public class ProductB implements Product {
     @Override
     public void method() {
         System.out.println("------ProductB------");
     }
 }

　　5.测试工厂方法

 public class TestFactoryMethod {
     /**
      * 创建不同的工厂，生产不同的产品
      * @param args
      */
     public static void main(String[] args) {
         AFactory aFactory = new AFactory();
         Product product = aFactory.create();
         product.method();

         BFactory bFactory = new BFactory();
         Product product1 = bFactory.create();
         product1.method();
         /* 输出为:
         ------ProductA------
         ------ProductB------*/
     }
 }

　　6.小结工厂方法

　　工厂方法模式是简单工厂模式的进一步抽象化和推广，工厂方法模式里不再只由一个工厂类决定那一个产品类应当被实例化，这个决定被交给抽象工厂的子类去做。工厂方法模式实现了不同产品在不同工厂生产，维护和扩展比简单工厂模式好，即使一个产品出现问题，其他产品也可以正常生产。

五、抽象工厂模式

　　1.抽象工厂类

 /**
  * 抽象工厂类
  * 可以创建分别生产A、B产品
  */
 public interface AbstractFactory {

     ProductA factoryA();

     ProductB factoryB();
 }

　　2.具体工厂

　　A1和B1是一个产品族，由具体工厂1生产；A2和B2是一个产品族，由具体工厂2生产

 /**
  * 具体工厂1
  * 生产产品A1和B1
  */
 public class Factory1 implements AbstractFactory {
     @Override
     public ProductA factoryA() {
         return new ProductA1();
     }

     @Override
     public ProductB factoryB() {
         return new ProductB1();
     }
 }

 /**
  * 具体工厂2
  * 生产产品A2和B2
  */
 public class Factory2 implements AbstractFactory {
     @Override
     public ProductA factoryA() {
         return new ProductA2();
     }

     @Override
     public ProductB factoryB() {
         return new ProductB2();
     }
 }

　　3.抽象产品接口

　　抽象产品A接口

 /**
  * 抽象产品A接口
  */
 public interface ProductA {
 }

　　抽象产品B接口

 /**
  * 抽象产品B接口
  */
 public interface ProductB {
 }

　　4.具体产品

　　具体产品A1，实现抽象产品A接口

 /**
  * 具体产品A1
  */
 public class ProductA1 implements ProductA {
     public ProductA1(){
         System.out.println("------ProductA1------");
     }
 }

　　具体产品A2，实现抽象产品A接口

 /**
  * 具体产品A2
  */
 public class ProductA2 implements ProductA {
     public ProductA2() {
         System.out.println("------ProductA2------");
     }
 }

　　具体产品B1，实现抽象产品B接口

 /**
  * 具体产品B1
  */
 public class ProductB1 implements ProductB {
     public ProductB1() {
         System.out.println("------ProductB1------");
     }
 }

　　具体产品B2，实现抽象产品B接口

 /**
  * 具体产品B2
  */
 public class ProductB2 implements ProductB {
     public ProductB2() {
         System.out.println("------ProductB2------");
     }
 }

　　5.测试抽象工厂

 /**
  * 测试抽象功能工厂
  */
 public class TestAbstractFactory {
     public static void main(String[] args) {
         Factory1 factory1 = new Factory1();
         factory1.factoryA();
         factory1.factoryB();

         Factory2 factory2 = new Factory2();
         factory2.factoryA();
         factory2.factoryB();
         /* 输出
         ------ProductA1------
         ------ProductB1------
         ------ProductA2------
         ------ProductB2------*/
     }
 }

　　6.小结

　　抽象工厂模式提供两个具体工厂角色，分别对应于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。

六、总结

简单工厂 ： 用来生产同一等级结构中的任意产品，即所有产品由一个工厂生产，当需要添加新产品时，需要修改工厂类，不易扩展。

工厂方法 ：用来生产同一等级结构中的固定产品，即不同的产品由不同的工厂生产，添加新产品只需要添加新工厂，更容易扩展，不过如果同一级产品有多个，会产生很多平行的工厂。

抽象工厂 ：用来生产不同产品族的全部产品，即一个工厂生产一个产品族，每个产品族都是多个产品的同一级结构。

以上三种工厂方法在等级结构和产品族这两个方向上的支持程度不同。所以要根据情况考虑应该使用哪种方法。