三种工厂模式总述

工厂模式实现了创建者和调用者的分离。 – 详细分类：

      1.简单工厂模式

      2.工厂方法模式

      3.抽象工厂模式

 

       工厂模式的核心本质： – 实例化对象，用工厂方法代替new操作。 – 将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

       工厂模式：

           – 简单工厂模式 ：用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已 有代码）

           – 工厂方法模式 ：用来生产同一等级结构中的固定产品。（支持增加任意产品）

           – 抽象工厂模式 ：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持 增加产品族）

 

   不使用工厂方法的情况

       代码的耦合度高，不易扩展

public class Client01 { //调用者
   public static void main(String[] args) {
      Car c1 = new Audi();
      Car c2 = new Byd();
      c1.run();
      c2.run();
}
}

 

    1、简单工厂模式

     简单工厂模式也叫静态工厂模式，就是工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。但对于增加新产品无能为力！不修改代码的话，是无法扩展的。

简单工厂一：

    传入一个名字，根据名字返回相应的产品

public class CarFactory { 
    public static Car createCar(String type){
         Car c = null; 
         if("奥迪".equals(type){      
	         c  = new Audi();
         }else if("奔驰".equals(type){
             c = new Benz();
        }
        return c;
   }
}

简单工厂二：

     直接创建出来

public class CarFactory {
  public static Car createAudi(){
    return new Audi();
  }
  public static Car createBenz(){
    return new Benz();
  }
}

 

 

    2、工厂方法模式

     为了避免简单工厂模式的缺点，不完全满足OCP。

    工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。这样做的目的，是在需要工厂创建新的类时，不用修改已有的代码，而是通过新增加工厂类的方式实现。

     这样我们就需要定义一个工厂类的接口，具体的工厂来生产具体的产品。通过一个UML图来说明：

     

每一个具体的工厂只负责生产具体的产品，这样在需要工厂生产新的产品时，不用修改原来的代码。

public interface FruitFactory {  //定义一个接口工厂
    Fruit createFruit();
}

class AppleFactory implements FruitFactory {   //具体的创建类型工厂
    @Override
    public Fruit createFruit() {
        return new Apple();
    }
}

class OrangeFactory implements FruitFactory{    //具体的创建类型工厂
    @Override
    public Fruit createFruit() {
        return new Orange();
    }
}

   定义水果：

public class Apple implements Fruit{  //定义水果
    @Override
    public void plant() {
        System.out.println("苹果种植");
    }

    @Override
    public void cultivate() {
        System.out.println("苹果培养");
    }

}
class Orange implements Fruit {
    @Override
    public void plant() {
        System.out.println("橘子种植");
    }

    @Override
    public void cultivate() {
        System.out.println("橘子培养");
    }
}

    使用：

* 工厂方法设计模式
* 包涵：
*     抽象产品（用与创建具体的产品）
*     具体产品（继承或实现抽象产品）
*     抽象工厂（工厂父类，工厂方法模式的核心）
*     具体工厂，用于生产具体的一种类
* 符合开闭原则（ocp），扩展方便
* */
public class client {
    public static void main(String[] args) {
        Fruit app=new AppleFactory().createFruit();//使用工厂创建对象
        app.cultivate();
        app.plant();

        System.out.println("===============");

        Fruit ora=new OrangeFactory().createFruit();
        ora.plant();
        ora.cultivate();
    }
}

   3、简单工厂模式和工厂方法模式PK:

       结构复杂度：从这个角度比较，显然简单工厂模式要占优。简单工厂模式只需一个工厂类，而工厂方法模式的工厂类随着产品类个数增加而增加，这无疑会使类的个数越来越多，从而增加了结构的复杂程度。

       代码复杂度：代码复杂度和结构复杂度是一对矛盾，既然简单工厂模式在结构方面相对简洁，那么它在代码方面肯定是比工厂方法模式复杂的了。简单工厂模式的工厂类随着产品类的增加需要增加很多方法（或代码），而工厂方法模式每个具体工厂类只完成单一任务，代码简洁。

      客户端编程难度：工厂方法模式虽然在工厂类结构中引入了接口从而满足了OCP，但是在客户端编码中需要对工厂类进行实例化。而简单工厂模式的工厂类是个静态类，在客户端无需实例化，这无疑是个吸引人的优点。

      管理上的难度：这是个关键的问题，工厂方法模式管理不易，因为用太多的类。

      根据设计理论建议使用工厂方法模式。但实际上，我们一般都用简单工厂模式。

 

4、抽象工厂模式

      用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）

      抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

      抽象工厂模式是支持产品族的，对于单个产品就不行了。用UML来表示关系：

    代码实现：

       定义轮胎的产品，分为低端和高端。

public interface Tyre {   //定义轮胎的产品族
    void revolve();
}
class LuxuryTyre implements Tyre{
    @Override
    public void revolve() {
        System.out.println("旋转不磨损！");
    }
}
class LowTyre implements Tyre{
    @Override
    public void revolve() {
        System.out.println("旋转磨损严重！");
    }
}

      定义座椅的产品，分为低端和高端。

public interface Seat{ //定义座椅的产品族
    void message();
}
class LuxurySeat implements Seat{   
    @Override
    public void message() {
        System.out.println("可以自动按摩！");
    }
}
class LowSeat implements Seat{
    @Override
    public void message() {
        System.out.println("不能按摩！");
    }
}

      定义工厂：

public interface CarFactory {  //定义工厂接口
    Seat createSeat();  
    Tyre createTyre();
}
class LowCarFactory implements CarFactory{   //定义生产低端产品族的工厂
    @Override
    public Seat createSeat() {
        return new LowSeat();
    }
    @Override
    public Tyre createTyre() {
        return new LowTyre();
    }
}
class LuxuryCarFactory implements CarFactory{   //生产高端产品族的工厂
    @Override
    public Seat createSeat() {
        return new LuxurySeat();
    }
    @Override
    public Tyre createTyre() {
        return new LuxuryTyre();
    }
}

       使用：

public class client {
    public static void main(String[] args) {
        CarFactory factory=new LuxuryCarFactory();   //定义生成高端产品的工厂

        Seat seat = factory.createSeat();
        seat.message();

        Tyre tyre = factory.createTyre();
        tyre.revolve();
    }
}

    总结：

      – 简单工厂模式(静态工厂模式)

          虽然某种程度不符合设计原则，但实际使用最多。

     – 工厂方法模式

          不修改已有类的前提下，通过增加新的工厂类实现扩展。

     – 抽象工厂模式

           不可以增加产品，可以增加产品族！