设计模式02-工厂模式

目的

工厂模式主要是为创建对象提供一些过渡接口，将创建对象的具体过程对外部屏蔽隔离起来，以达到较高的灵活性的目的

分类

工厂模式主要分为三类：

1）简单工厂模式（Simple Factory）
2）工厂方法模式（Factory Method）
3）抽象工厂模式（Abstract Factory）

这三种模式从上到下逐步抽象，并且更具一般性。

GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。

将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。

区别

模式 区别 工厂模式 具有一个抽象工厂类 具有一个抽象产品类 一个抽象工厂类可以派生出多个实体工厂类 （简单工厂只有一个实体工厂类） 一个抽象产品类也可以派生出多个实体产品类 一个实体工厂只能生产一个实体产品 抽象工厂模式 具有一个抽象工厂类 具有多个抽象产品类 每个抽象工厂类可以对应多个具体工厂类 每个抽象产品类可以对应多个具体产品类 每个具体工厂类可以对应多个具体产品类

关系图

简单工厂模型

一个工厂类
一个抽象产品类
多个具体产品类

工厂模型

一个抽象工厂类
一个抽象产品类
多个具体工厂类和多个具体产品类
一个具体工厂类对应一个具体产品类

抽象工厂模型

一个抽象工厂类
多个抽象产品类
一个抽象工厂类对应多个具体工厂类
一个抽象产品类对应多个具体产品类
一个具体工厂类对应多个具体产品类

实例

简单工厂类

//一个抽象产品类abstract class Car {      public Car(){      }  }  //一个具体产品类  public class BMW extends Car {      public BMW() {          System.out.println("制造-->BMW");      }  }//一个具体产品类  public class Porsche extends Car{      public Porsche(){          System.out.println("制造-->Porsche");      }  } //一个工厂类public class Factory {      public BMW createBMW(Car type) {          if(null == type){            return null;        }else if(type instanceOf BMW){            return new BMW();        }else if(type instanceOf Porsche){            return new Porsche();        }else {            return null;        }     }  }

工厂类

//一个抽象产品类abstract class Car {      public Car(){      }  }  //一个具体产品类  public class BMW extends Car {      public BMW() {          System.out.println("制造-->BMW");      }  }//一个具体产品类  public class Porsche extends Car{      public Porsche(){          System.out.println("制造-->Porsche");      }  } //一个抽象工厂类interface FactoryCar {      Car createCar();  }  //一个具体工厂类对应一个具体产品  public class FactoryBMW implements FactoryCar{      @Override      public Car createBMW() {          return new BMW();      }  } //一个具体工厂类对应一个具体产品 public class FactoryPorsche implements FactoryCar {      @Override      public Car createCar() {          return new Porsche();      }  } 

抽象工厂类

//一个抽象工厂类，定义了生产族产品的方法；  public interface AbstractFactory {      public ProductA factoryA();      public ProductB factoryB(); //抽象产品A定义了产品的公共方法，产品A和B属于一个产品族  public interface ProductA {      public void method1();      public void method2();  }  //抽象产品B定义了产品的公共方法，产品A和B属于一个产品族  public interface ProductB {      public void method1();      public void method2();  } //一个抽象产品对应多个具体产品：等级为1的具体产品A  public class ConcreateProductA1 implements ProductA {      @Override      public void method1() {          // TODO Auto-generated method stub          System.out.println("等级为1的产品A的method1()");      }      @Override      public void method2() {          // TODO Auto-generated method stub          System.out.println("等级为1的产品A的method2()");      }  } //一个抽象产品对应多个具体产品：等级为2的具体产品A  public class ConcreateProductA2 implements ProductA {      @Override      public void method1() {          // TODO Auto-generated method stub          System.out.println("等级为2的产品A的method1()");      }      @Override      public void method2() {          // TODO Auto-generated method stub          System.out.println("等级为2的产品A的method2()");      }  } //一个抽象产品对应多个具体产品：等级为1的产品B  public class ConcreateProductB1 implements ProductB{      @Override      public void method1() {          // TODO Auto-generated method stub          System.out.println("等级为1的产品B的method1()");      }      @Override      public void method2() {          // TODO Auto-generated method stub          System.out.println("等级为1的产品B的method2()");      }  } //一个抽象产品对应多个具体产品：等级为2的产品B  public class ConcreateProductB2 implements ProductB {      @Override      public void method1() {          // TODO Auto-generated method stub          System.out.println("等级为2的产品B的method1()");      }      @Override      public void method2() {          // TODO Auto-generated method stub          System.out.println("等级为2的产品B的method2()");      }  } //一个抽象工厂对应多个具体工厂，一个具体工厂对应多个具体产品：ConcreateFactory1是用来生产等级为1的产品A，B；  public class ConcreateFactory1 implements AbstractFactory {      //生产等级为1的产品A      @Override      public ProductA factoryA() {          // TODO Auto-generated method stub          return new ConcreateProductA1();      }      //生产等级为1的产品B      @Override      public ProductB factoryB() {          // TODO Auto-generated method stub          return new ConcreateProductB1();      }  }//一个抽象工厂对应多个具体工厂，一个具体工厂对应多个具体产品：public class ConcreateFactory2 implements AbstractFactory {      //生产等级为2的产品A      @Override      public ProductA factoryA() {          // TODO Auto-generated method stub          return new ConcreateProductA2();      }      //生产等级为2的产品B      @Override      public ProductB factoryB() {          // TODO Auto-generated method stub          return new ConcreateProductB2();      }  }  

总结

模式 优点 缺点 简单工厂 工厂类中增加了业务判断逻辑，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。 没有遵守开放—封闭原则。所谓的“开放-封闭”原则就是开放接口，封闭修改。如果将来需要添加一个开方的算法，那么，在简单工厂模式中，就必须在简单工厂类中添加相应的判断语句 工厂模型 进一步抽象和推广。它遵循了“开放—封闭”原则 把简单工厂的内部逻辑判断转移到了客户端代码来执行；每增加一产品就要增加一个产品工厂的类，增加了额外的开发量。 抽象工厂 让具体的创建实例过程与客户端分离，客户端是通过他们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户端代码中。 随着产品的增加，会产生更多的具体工厂和具体产品类