工厂模式

工厂模式可以分为三类：
1）简单工厂模式（Simple Factory）
2）工厂方法模式（Factory Method）
3）抽象工厂模式（Abstract Factory）

 定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。

抽象产品类负责定义产品共性，实现对事物最抽象的定义。
工厂模式具有良好的封装性，代码结构清晰，一个对象创建是有条件约束的，如一个调用者需要一个具体的产品对象，只要知道这个产品的类名就可以了，不用知道创建对象的艰辛过程，降低模块间的耦合。

简单工厂模式通用源码：

抽象产品类：

public abstract class Product {  public void method1(){   }  public abstract void method2();}

具体产品类：

public class ConcreteProduct1 extends    Product {  public void method2() {  }} public class ConcreteProduct2 extends Product {   public void method2() { }}

抽象工厂类

 public abstract class Creator {    public abstract <T extends Product> T createProduct(Class<T> c);  }

具体工厂类

public class ConcreteCreator extends Creator {      public <T extends Product> T createProduct(Class<T> c){      Product product=null;      try {         product = (Product)Class.forName(c.getName()).newInstance();    } catch (Exception e) {    }           return (T)product;      }}

场景类：

public class Client {     public static void main(String[] args) {    Creator creator = new ConcreteCreator();    Product product = creator.createProduct(ConcreteProduct1.class);  }}

工厂方法是针对每一种产品提供一个工厂类 。通过不同的工厂实例来创建不同的产品实例
工厂模式使用场景：

• 一、工厂方法模式是new一个对象的替代品，所有在所有需要生成对象的地方都可以使用，但需要慎重考虑是否需要增加一个工厂类进行管理，增加代码复杂度。
• 二、需要灵活的可扩展的框架时。
• 三、在异构项目
• 四、可以使用在测试驱动开发的框架下。

工厂方法模式

工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化哪一个。这个决定被交给抽象工厂的子类去做。来看下它的组成：   1)抽象工厂角色： 是具体工厂角色必须实现的接口或者必须继承的父类。   2)具体工厂角色：它含有和具体业务逻辑有关的代码。用来创建具体的对象   3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。   4)具体产品角色：由具体的工厂角色所创建的对象就是此角色的实例。

相当于在调用时直接通过每一个具体工厂角色来创建所需要的产品角色，这里具体工厂角色和具体产品角色就有了一个一一对应的关系，但是这样在有多个产品角色是，具体工厂角色就会变的很多，这不是我们所希望的，因此可以与简单工厂模式配合使用
工厂方法模式的核心是定义一个抽象工厂类,而不像简单工厂模式, 把核心放在一个实体类上。如果系统中只需要有一个工厂类，则使用简单工厂模式即可。

抽象工厂模式

为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类

相当于在抽象工厂类中定义相关的抽象方法，然后再在具体工厂类中根据具体去实现，当抽象产品只有一个时就与工厂方法模式类似了。下面是《设计模式之禅》中的实例
抽象工厂类：

 public abstract class AbstractCreator {    public abstract AbstractProductA createProductA();    public abstract AbstractProductB createProductB();  }

具体工厂类1：

public class Creator1 extends AbstractCreator {   public AbstractProductA createProductA() {           return new ProductA1();   }   public AbstractProductB createProductB() {        return new ProductB1();   }}

具体工厂类2：

public class Creator2 extends AbstractCreator {   public AbstractProductA createProductA() {          return new ProductA2();   }   public AbstractProductB createProductB() {      return new ProductB2();   }}

抽象产品类A:

public abstract class AbstractProductA {    public void shareMethod(){   }   public abstract void doSomething();}

抽象产品类B:

public abstract class AbstractProductB {   public void shareMethod(){   }   public abstract void doSomething();}

产品A1:

 public class ProductA1 extends AbstractProductA {   @Override   public void doSomething() {      System.out.println("");   }}

产品A2:

 public class ProductA2 extends AbstractProductA {  @Override   public void doSomething() {        System.out.println("");   }}

产品B1:

 public class ProductB1 extends AbstractProductB { @Override  public void doSomething() {     System.out.println("");  }}

产品B2:

public class ProductB2 extends AbstractProductB {@Override public void doSomething() {     System.out.println("");  }}

客户端类：

public class Client {  public static void main(String[] args) {    AbstractCreator creator1 = new Creator1();    AbstractCreator creator2 = new Creator2();    AbstractProductA a1 =  creator1.createProductA();    AbstractProductA a2 = creator2.createProductA();    AbstractProductB b1 = creator1.createProductB();    AbstractProductB b2 = creator2.createProductB();  }}