简单工厂/工厂/抽象工厂模式（创建类）

概述

无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。定义一个用户创建对象的接口，让子类决定实例化哪一个。

---

简单工厂模式

又叫静态工厂模式，包括工厂，抽象产品，具体产品三个角色，是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。类图如下：

1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体静态类实现。

2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。

3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

demo实现：

//抽象产品角色
public interface Car{
public void drive(); 
}


//具体产品角色
public class Benz implements Car{
public void drive()  {
System.out.println("Driving Benz ");
}
}

public class Bmw implements Car{
public void drive()  {
System.out.println("Driving Bmw ");
}
}
。。。

//工厂类角色

public class Driver{
//工厂方法.注意 返回类型为抽象产品角色
       public static Car driverCar(String s)throws Exception    {

              //判断逻辑，返回具体的产品角色给Client
              if(s.equalsIgnoreCase("Benz"))  

                    return new Benz();

              else if(s.equalsIgnoreCase("Bmw"))

                     return new Bmw();

                    ......   
             else throw new Exception();

       。。。

//欢迎暴发户出场......
public class Magnate{

       public static void main(String[] args){

              try{ 
                     //告诉司机我今天坐奔驰              
                     Car car = Driver.driverCar("benz"); 
                     //下命令：开车                   
                     car.drive();

              。。。

优缺点

优点：
工厂类是整个模式的关键所在。它包含必要的判断逻辑，能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。用户在使用时可以直接根据工厂类去创建所需的实例，而无需了解这些对象是如何创建以及如何组织的。有利于整个软件体系结构的优化。

缺点：
由于工厂类集中了所有实例的创建逻辑，这就直接导致一旦这个工厂出了问题，所有的客户端都会受到牵连；而且由于简单工厂模式的产品室基于一个共同的抽象类或者接口，这样一来，但产品的种类增加的时候，即有不同的产品接口或者抽象类的时候，工厂类就需要判断何时创建何种种类的产品，这就和创建何种种类产品的产品相互混淆在了一起，违背了单一职责，导致系统丧失灵活性和可维护性。而且更重要的是，简单工厂模式违背了“开放封闭原则”，就是违背了“系统对扩展开放，对修改关闭”的原则，因为当我新增加一个产品的时候必须修改工厂类，相应的工厂类就需要重新编译一遍。

总结：
简单工厂模式分离产品的创建者和消费者，有利于软件系统结构的优化；但是由于一切逻辑都集中在一个工厂类中，导致了没有很高的内聚性，同时也违背了“开放封闭原则”。另外，简单工厂模式的方法一般都是静态的，而静态工厂方法是无法让子类继承的，因此，简单工厂模式无法形成基于基类的继承树结构。

---

工厂模式

工厂模式在简单工厂的基础上，完善了工厂类，提供了抽象工厂，具体工厂角色。把简单工厂通过逻辑判断的具体产品的实例化，通过特定的具体工厂直接实现对应的具体产品类。类图如下：

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

2) 具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。

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

4) 具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

demo实现

//抽象产品角色，具体产品角色与简单工厂模式类似，只是变得复杂了些，这里略。
//抽象工厂角色
public interface Driver{
       public Car driverCar();
}

public class BenzDriver implements Driver{
       public Car driverCar(){
           return new Benz();
       }
}

public class BmwDriver implements Driver{
       public Car driverCar() {
           return new Bmw(); 
       }
}

//应该和具体产品形成对应关系...
//有请暴发户先生
public class Magnate
{
     public static void main(String[] args)

      {

             try{ 
                    Driver driver = new BenzDriver();
                    Car car = driver.driverCar();
                    car.drive();
             }
       …… 
}

优缺点

优点
更加满足开闭原则。

缺点
工厂方法的加入，使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。因为如果不能避免这种情况，可以考虑使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类：即对于产品树上类似的种类（一般是树的叶子中互为兄弟的）使用简单工厂模式（简单工厂模式工厂类一般不能被继承）来实现。在工厂方法模式中，要么将判断逻辑留在抽象工厂角色中，要么在客户程序中将具体工厂角色写死（就象上面的例子一样）。而且产品对象创建条件的改变必然会引起工厂角色的修改。

---

抽象工厂模式

抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。
在抽象工厂模式中，有一个产品族的概念：所谓的产品族，是指位于不同产品等级结构中功能相关联的产品组成的家族。抽象工厂模式所提供的一系列产品就组成一个产品族；而工厂方法提供的一系列产品称为一个等级结构。
类图如下：

demo实现

// 产品 Plant接口      
public interface Plant { }//标志接口    
//具体产品PlantA，PlantB      
public class PlantA implements Plant {       
　public PlantA () {      
　　System.out.println("create PlantA !");      
　}         
　public void doSomething() {      
　　System.out.println(" PlantA do something ...");      
　}      
}      
public class PlantB implements Plant {      
　public PlantB () {      
　　System.out.println("create PlantB !");      
　}      

　public void doSomething() {      
　　System.out.println(" PlantB do something ...");      
　}      
}      
// 产品 Fruit接口      
public interface Fruit { }      
//具体产品FruitA，FruitB      
public class FruitA implements Fruit {      
　public FruitA() {      
　　System.out.println("create FruitA !");      
　}      
　public void doSomething() {      
　　System.out.println(" FruitA do something ...");      
　}      
}      
public class FruitB implements Fruit {      
　public FruitB() {      
　　System.out.println("create FruitB !");      
　}      
　public void doSomething() {      
　　System.out.println(" FruitB do something ...");      
　}      
}      
// 抽象工厂方法      
public interface AbstractFactory {      
　public Plant createPlant();      
　public Fruit createFruit();      
}      
//具体工厂方法      
public class FactoryA implements AbstractFactory {      
　public Plant createPlant() {      
　　return new PlantA();      
　}      
　public Fruit createFruit() {      
　　return new FruitA();      
　}      
}      
public class FactoryB implements AbstractFactory {      
　public Plant createPlant() {      
　　return new PlantB();      
　}      
　public Fruit createFruit() {      
　　return new FruitB();      
　}      
}     
Java代码   收藏代码
//调用工厂方法     
public Client {     
      public method1() {     
             AbstractFactory instance = new FactoryA();     
             instance.createPlant();     
       }     
}  

优缺点

优点
抽象工厂模式除了具有工厂方法模式的优点外，最主要的优点就是可以在类的内部对产品族进行约束。所谓的产品族，一般或多或少的都存在一定的关联，抽象工厂模式就可以在类内部对产品族的关联关系进行定义和描述，而不必专门引入一个新的类来进行管理。

缺点
产品族的扩展将是一件十分费力的事情，假如产品族中需要增加一个新的产品，则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时，对产品等级结构的划分是非常重要的。

适用场景
当需要创建的对象是一系列相互关联或相互依赖的产品族时，便可以使用抽象工厂模式。说的更明白一点，就是一个继承体系中，如果存在着多个等级结构（即存在着多个抽象类），并且分属各个等级结构中的实现类之间存在着一定的关联或者约束，就可以使用抽象工厂模式。假如各个等级结构中的实现类之间不存在关联或约束，则使用多个独立的工厂来对产品进行创建，则更合适一点。

---

总结

无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。
所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了。