设计模式之工厂设计模式

话说十年前，有一个爆发户，他家有三辆汽车（Benz（奔驰）、Bmw（宝马）、Audi（奥迪）），还雇了司机为他开车。不过，爆发户坐车时总是这样：上Benz车后跟司机说“开奔驰车！”，坐上Bmw后他说“开宝马车！”，坐上 Audi后他说“开奥迪车！”。
你一定说：这人有病！直接说开车不就行了？！而当把这个爆发户的行为放到我们程序语言中来，我们发现C语言一直是通过这种方式来坐车的！
幸运的是这种有病的现象在OO语言中可以避免了。下面以Java语言为基础来引入我们本文的主题：工厂模式！

什么是工厂设计模式？

工厂设计模式，顾名思义，就是用来生产对象的，在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则，如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说，工厂模式最大的优点就是：解耦

 

工厂模式主要是为了创建对象提供接口，工厂模式分为三类：

3. 简单工厂模式
4. 工厂方法模式
5. 抽象工厂模式

那么在什么样的情况下我们需要使用工厂模式呢？

　　1.在编码时不能预见需要创建哪种类的实例。
　　2.系统不应依赖于产品类实例如何被创建、组合和表达的细节

简单工厂模式

现将产品类抽象出来，比如奔驰宝马都是汽车，抽象一个car类 然后创建具体汽车类

package Factory;

import java.io.IOException;

//抽象产品  
abstract class Car{  
  private String name;  
    
  public abstract void drive();  
    
  public String getName() {  
      return name;  
  }  
  public void setName(String name) {  
      this.name = name;  
  }  
}  
//具体产品  
class Benz extends Car{  
  public void drive(){  
      System.out.println(this.getName()+"----go-----------------------");  
  }  
}  

class Bmw extends Car{  
  public void drive(){  
      System.out.println(this.getName()+"----go-----------------------");  
  }  
}  

//简单工厂  
class Driver{  
  public static Car createCar(String car){  
      Car c = null;  
      if("Benz".equalsIgnoreCase(car))  
          c = new Benz();  
      else if("Bmw".equalsIgnoreCase(car))  
          c = new Bmw();  
      return c;  
  }  
}  

//老板  
public class BossSimplyFactory {  

  public static void main(String[] args) throws IOException {  
      //老板告诉司机我今天坐奔驰  
      Car car = Driver.createCar("benz");  
      car.setName("benz");  
       //司机开着奔驰出发  
      car.drive();  
  }  
}

有什么好处？

合现实中的情况；而且客户端免除了直接创建产品对象的责任，而仅仅负责“消费”产品（正如暴发户所为）。
下面我们从开闭原则上来分析下简单工厂模式。当暴发户增加了一辆车的时候，只要符合抽象产品制定的合同，那么只要通知工厂类知道就可以被客户使用了。（即创建一个新的车类，继承抽象产品Car）那么 对于产品部分来说，它是符合开闭原则的——对扩展开放、对修改关闭；但是工厂类不太理想，因为每增加一辆车，都要在工厂类中增加相应的商业逻辑和判 断逻辑，这显自然是违背开闭原则的。

简单工厂模式适用于业务简单的情况下或者具体产品很少增加的情况。而对于复杂的业务环境可能不太适应了。这就应该由工厂方法模式来出场了！！

工厂方法模式

抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。
抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
来用类图来清晰的表示下的它们之间的关系：

话说暴发户生意越做越大，自己的爱车也越来越多。这可苦了那位司机师傅了，什么车它都要记得，维护，都要经过他来使用！于是暴发户同情他说：我给你分配几个人手，你只管管好他们就行了！于是工厂方法模式的管理出现了。代码如下：

    //抽象产品  
    abstract class Car{  
        private String name;  
          
        public abstract void drive();  
          
        public String getName() {  
            return name;  
        }  
        public void setName(String name) {  
            this.name = name;  
        }  
    }  
    //具体产品  
    class Benz extends Car{  
        public void drive(){  
            System.out.println(this.getName()+"----go-----------------------");  
        }  
    }  
    class Bmw extends Car{  
        public void drive(){  
            System.out.println(this.getName()+"----go-----------------------");  
        }  
    }  
      
      
    //抽象工厂  
    abstract class Driver{  
        public abstract Car createCar(String car) throws Exception;  
    }  
    //具体工厂（每个具体工厂负责一个具体产品）  
    class BenzDriver extends Driver{  
        public Car createCar(String car) throws Exception {  
            return new Benz();  
        }  
    }  
    class BmwDriver extends Driver{  
        public Car createCar(String car) throws Exception {  
            return new Bmw();  
        }  
    }  
      
    //老板  
    public class Boss{  
      
        public static void main(String[] args) throws Exception {  
            Driver d = new BenzDriver();  
            Car c = d.createCar("benz");   
            c.setName("benz");  
            c.drive();  
        }  
    }  

 使用开闭原则来分析下工厂方法模式。当有新的产品（即暴发户的汽车）产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有的代码。（即当有新产品时，只要创建并基础抽象产品；新建具体工厂继承抽象工厂；而不用修改任何一个类）工厂方法模式是完全符合开闭原则的！

 使用工厂方法模式足以应付我们可能遇到的大部分业务需求。但是当产品种类非常多时，就会出现大量的与之对应的工厂类，这不应该是我们所希望的。所以我建议在这种情况下使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类：即对于产品树上类似的种类（一般是树的叶子中互为兄弟的）使用简单工厂模式来实现。
当然特殊的情况，就要特殊对待了：对于系统中存在不同的产品树，而且产品树上存在产品族（下一节将解释这个名词）。那么这种情况下就可能可以使用抽象工厂模式了。

小结

让我们来看看简单工厂模式、工厂方法模式给我们的启迪：
如果不使用工厂模式来实现我们的例子，也许代码会减少很多——只需要实现已有的车，不使用多态。但是在可维护性上，可扩展性上是非常差的（你可以想象一下添加一辆车后要牵动的类）。因此为了提高扩展性和维护性，多写些代码是值得的。

 抽象工厂模式

 先来认识下什么是产品族： 位于不同产品等级结构中，功能相关联的产品组成的家族。

可以这么说，它和工厂方法模式的区别就在于需要创建对象的复杂程度上。而且抽象工厂模式是三个里面最为抽象、最具一般性的。抽象工厂模式的用意为：给客户端提供一个接口，可以创建多个产品族中的产品对象。
而且使用抽象工厂模式还要满足一下条件：
1.系统中有多个产品族，而系统一次只可能消费其中一族产品
2.同属于同一个产品族的产品以其使用。

其中：BenzSportCar和BenzBusinessCar属于产品树；同理BmwSportCar和BmwBusinessCar。而BenzSportCar和BmwSportCar和AudiSportCar属于产品族。

所以抽象工厂模式一般用于具有产品树和产品族的场景下。

抽象工厂模式的缺点：如果需要增加新的产品树，那么就要新增三个产品类，比如VolvoCar，VolvoSportCar,VolvoSportCar，并且要修改三个工厂类。这样大批量的改动是很丑陋的做法。

所以可以用简单工厂配合反射来改进抽象工厂：

    abstract class BenzCar{  
        private String name;  
          
        public abstract void drive();  
          
        public String getName() {  
            return name;  
        }  
        public void setName(String name) {  
            this.name = name;  
        }  
    }  
    class BenzSportCar extends BenzCar{  
        public void drive(){  
            System.out.println(this.getName()+"----BenzSportCar-----------------------");  
        }  
    }  
    class BenzBusinessCar extends BenzCar{  
        public void drive(){  
            System.out.println(this.getName()+"----BenzBusinessCar-----------------------");  
        }  
    }  
      
    abstract class BmwCar{  
        private String name;  
          
        public abstract void drive();  
          
        public String getName() {  
            return name;  
        }  
        public void setName(String name) {  
            this.name = name;  
        }  
    }  
    class BmwSportCar extends BmwCar{  
        public void drive(){  
            System.out.println(this.getName()+"----BmwSportCar-----------------------");  
        }  
    }  
    class BmwBusinessCar extends BmwCar{  
        public void drive(){  
            System.out.println(this.getName()+"----BmwBusinessCar-----------------------");  
        }  
    }  
      
    abstract class AudiCar{  
        private String name;  
          
        public abstract void drive();  
          
        public String getName() {  
            return name;  
        }  
        public void setName(String name) {  
            this.name = name;  
        }  
    }  
    class AudiSportCar extends AudiCar{  
        public void drive(){  
            System.out.println(this.getName()+"----AudiSportCar-----------------------");  
        }  
    }  
    class AudiBusinessCar extends AudiCar{  
        public void drive(){  
            System.out.println(this.getName()+"----AudiBusinessCar-----------------------");  
        }  
    }  
      
      
    /** 
     * 简单工厂通过反射改进抽象工厂及其子工厂 
     * @author Administrator 
     * 
     */  
    class Driver3{  
        public static BenzCar createBenzCar(String car) throws Exception {  
            return (BenzCar) Class.forName(car).newInstance();  
        }  
          
        public static BmwCar createBmwCar(String car) throws Exception {  
            return (BmwCar) Class.forName(car).newInstance();  
        }  
          
        public static AudiCar createAudiCar(String car) throws Exception {  
            return (AudiCar) Class.forName(car).newInstance();  
        }  
    }  
    //客户端  
    public class SimpleAndAbstractFactory {  
      
        public static void main(String[] args) throws Exception {  
      
            AudiCar car = Driver3.createAudiCar("com.java.pattendesign.factory.AudiSportCar");  
            car.drive();  
        }  
    }  

 学习参考转自：https://www.cnblogs.com/zhangchenliang/p/3700820.html