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();
}

/抽象产品
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();  }
}

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

图中的BmwCar和BenzCar就是两个产品树（产品层次结构）；而如图所示的BenzSportsCar和BmwSportsCar就是一个产品族。他们都可以放到跑车家族中，因此功能有所关联。同理BmwBussinessCar和BenzBusinessCar也是一个产品族。

可以这么说，它和工厂方法模式的区别就在于需要创建对象的复杂程度上。而且抽象工厂模式是三个里面最为抽象、最具一般性的。

抽象工厂模式的用意为：给客户端提供一个接口，可以创建多个产品族中的产品对象。

而且使用抽象工厂模式还要满足一下条件：

1.系统中有多个产品族，而系统一次只可能消费其中一族产品

2.同属于同一个产品族的产品以其使用。

抽象工厂方法
//抽象产品（Bmw和Audi同理）
abstract class BenzCar{  private String name;  public abstract void drive();  public String getName() {  return name;  }  public void setName(String name) {  this.name = name;  }
}
//具体产品（Bmw和Audi同理）
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-----------------------");  }
}  //抽象工厂
abstract class Driver3{  public abstract BenzCar createBenzCar(String car) throws Exception;  public abstract BmwCar createBmwCar(String car) throws Exception;  public abstract AudiCar createAudiCar(String car) throws Exception;
}
//具体工厂
class SportDriver extends Driver3{  public BenzCar createBenzCar(String car) throws Exception {  return new BenzSportCar();  }  public BmwCar createBmwCar(String car) throws Exception {  return new BmwSportCar();  }  public AudiCar createAudiCar(String car) throws Exception {  return new AudiSportCar();  }
}
class BusinessDriver extends Driver3{  public BenzCar createBenzCar(String car) throws Exception {  return new BenzBusinessCar();  }  public BmwCar createBmwCar(String car) throws Exception {  return new BmwBusinessCar();  }  public AudiCar createAudiCar(String car) throws Exception {  return new AudiBusinessCar();  }
}  //老板
public class BossAbstractFactory {  public static void main(String[] args) throws Exception {  Driver3 d = new BusinessDriver();  AudiCar car = d.createAudiCar("");  car.drive();  }
}

优点

简单工厂模式：

1、工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅"消费"产品。实现了对责任的分割。

2、根据外界给定的信息，决定创建哪个具体类的对象。可以从直接创建具体产品对象的尴尬局面中摆脱出来。

3、外界与具体类隔离开来，偶合性低。明确区分了各自的职责和权力，有利于整个软件体系结构的优化。

工厂方法模式：

1、每个具体工厂类只完成单一任务，代码简洁。

2、工厂方法模式完全满足OCP，即它有非常良好的扩展性。                    

抽象工厂模式：

1、分离了具体的类，帮助你控制一个应用创建的对象的类，封装创建产品对象的责任和过程。将客户和类的实现分离，通过抽象接口操纵实例。

2、产品的类名在具体工厂的实现中被分离，它们不出现在客户代码中。它使得易于交换产品系列。

3、一个具体工厂类在一个应用中仅出现一次——即在它初始化的时候。这使得改变一个应用的具体工厂变得很容易。只需改变具体的工厂即可使用不同的产品配置。它有利于产品的一致性。

4、抽象工厂模式团队的分工，降低了模块间的耦合性，提高了团队开发效率。

缺点

简单工厂模式：

1、一旦增加产品或者删除产品，整个系统都要受到影响。系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，有可能造成工厂逻辑过于复杂,违背了"开放--封闭"原则(OCP).

2、简单工厂模式通常使用静态工厂方法，这使得无法由子类继承，造成工厂角色无法形成基于继承的等级结构。

工厂方法模式：

1、某个具体产品类需要进行一定的修改，很可能需要修改对应的工厂类。

2、当同时需要修改多个产品类的时候，对工厂类的修改会变得相当麻烦。

抽象工厂模式：

1、抽象工厂模式在于难于应付“新对象”的需求变动。难以支持新种类的产品。

难以扩展抽象工厂以生产新种类的产品。

2、抽象工厂几乎确定了可以被创建的产品集合，支持新种类的产品就需要扩展该工厂接口

适用范围

简单工厂模式：

工厂类负责创建的对象比较少，客户只知道传入了工厂类的参数，对于始何创建对象（逻辑）不关心。

工厂方法模式：

当一个类不知道它所必须创建对象的类或一个类希望由子类来指定它所创建的对象时，当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候，可以使用工厂方法，支持多扩展少修改的OCP原则。

抽象工厂模式：

一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有形态的工厂模式都是重要的。这个系统有多于一个的产品族，而系统只消费其中某一产品族。同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。

总结

其实，无论是简单工厂模式、工厂方法模式还是抽象工厂模式，它们本质上都是将不变的部分提取出来，将可变的部分留作接口，以达到最大程度上的复用。究竟用哪种设计模式更适合，这要根据具体的业务需求来决定。

思维导图

码个蛋专属活动：打卡入口

为什么要做这个活动？

帮你养成好习惯（第四弹）

关注「码个蛋」，一起打卡成长

关注后可获得码仔专属表情包