工厂方法模式、简单工厂模式、抽象工程模式

1.概述

工厂设计模式是一种创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

1.1. 针对的问题

在面向对象编程中，最常用的方法是new一个操作符产生一个对象实例，new对象操作符就是用来构造对象实例的，但是在一些情况下，new操作符直接生成对象会带来一些问题，举例说，许多类型对象的创建都需要一系列的步骤，可能需要计算或取得对象的初始设置，选择生成哪个子对象实例，或者在生成需要的对象之前必须先生成一些辅助功能的对象，这些情况下，对象的建立就是一个过程，不仅是一个操作。

1.2. 分析

上图就是没有工厂模式时，用户需要自己new一辆车，这样，车和人就耦合在了一起。
那么怎么能够方便的构建对象实例，而不关心构造对象实例的细节和复杂过程呢，那就是建立一个工厂来创建对象。把创建的过程封装到工厂里。

1.3. 工厂模式类型

工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到灵活性的目的。
工厂模式一共三类

1. 简单工厂模式
2. 工厂方法模式
3. 抽象工厂模式

一般将简单工厂模式看为工厂方法模式的一种特例，二者归为一类。

2. 三种工厂模式特征及实现

2.1 简单工厂模式

2.1.1. 角色组成

1. 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品

2. 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。

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

2.1.2. 实现

//产品类
abstract class BMW{
	public BMW(){}
}

//具体产品类
public class BMW100 extends BMW{
	public BMW100(){
	    System.out.println("this is BMW100");
	}
}
public class BMW200 extends BMW{	
	public BMW200(){
		System.out.println("this is BMW200");
   }
}

//工厂类
public class Factory{
	public BMW CreateBMW(int type){
		if(type ==100) return new BMW100();
		if(type ==200) return new BMW200();
		else return null;
    }
}

2.1.3. 分析

在简单工厂中，当客户不再满足现有的车型号时，想要一种更快的车，只要这种车满足抽象产品指定的规则，只要通知工厂类增加相应的逻辑就好了，但是每增加一种车，都要在工厂类中增加相应的逻辑，工厂类十分被动，这样的工厂类成为全能类或者上帝类。

2.2 工厂方法模式

2.2.1. 角色构成

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

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

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

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

工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的上帝类，分担了对象承受的压力。

2.2.2. 实现

//抽象产品类
abstract class BMW()
{
    public BMW();
}

// 具体产品类 四种车，宝马1系，(两种),2系(两种)
public class BMW100 extends BMW
{
	public BMW100()
	{
		System.out.println("this is BMW100");
	}
}
public class BMW109 extends BMW
{
	public BMW109()
	{
		System.out.println("this is BMW100");
	}
}
public class BMW200 extends BMW
{
	public BMW200()
	{
		System.out.println("this is BMW200");
	}
}
public class BMW209 extends BMW
{
	public BMW209()
	{
		System.out.println("this is BMW209");
	}
}

//抽象工厂角色
interface Factory
{
    BMW createBMW();
}

//具体工厂角色
public class FactoryBMW1 implements FactoryBMW{  
  
    @Override  
    public BMW100 createBMW() {  
        return new BMW100();  
    }  
  
}  
public class FactoryBMW2 implements FactoryBMW {  
    @Override  
    public BMW200 createBMW() {  
  
        return new BMW200();  
    }  
}   //分为100的工厂和200的工厂(省略了两个工厂)。都实现了工厂的接口

2.2.3. 分析

想加一辆车，就单独加车的类，这个车的工厂，然后只修改客户端的代码即可。工厂方法模式实现时，客户端需要决定实例化哪一个工厂来创建对象，工厂方法把简单工厂的内部逻辑移到了客户端代码来执行。

2.3. 抽象工厂模式

抽象工厂模式是工厂方法模式的升级版本，它用来创建一组相关或者相互依赖的对象。

抽象工厂模式提供一个创建一系列相关或者相互依赖对象的接口，而无需指定他们具体的类。就是一个工厂里放一些相关的类，使工厂数减少。

最大的好处便是易于交换产品系列，其次是让具体的创建实例过程与客户端分离，客户端通过他们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离。不会出现在客户代码中

2.3.1. 角色

2.3.2. 实现

抽象工厂方法就是一个工厂里生产不同等级结构中的一个（其中一种车）中的不同的配件（不同的车的属性）

//抽象产品类1 发动机以及型号    
public interface Engine {    
  
}    
//抽象产品类2 空调以及型号    
public interface Aircondition {    
  
}

//具体产品类
public class EngineA extends Engine{    
    public EngineA(){    
        System.out.println("制造-->EngineA");    
    }    
}    
public class EngineB extends Engine{    
    public EngineB(){    
        System.out.println("制造-->EngineB");    
    }    
}  
    
public class AirconditionA extends Aircondition{    
    public AirconditionA(){    
        System.out.println("制造-->AirconditionA");    
    }    
}    
public class AirconditionB extends Aircondition{    
    public AirconditionB(){    
        System.out.println("制造-->AirconditionB");    
    }    
}

//抽象工厂    
public interface AbstractFactory {    
    //制造发动机  
    public Engine createEngine();  
    //制造空调   
    public Aircondition createAircondition();   
}    

//具体工厂类  
public class 奔驰工厂 implements AbstractFactory{    
        
    @Override    
    public Engine createEngine() {      
        return new EngineA();    
    }    
    @Override    
    public Aircondition createAircondition() {    
        return new AirconditionA();    
    }    
}    
//为宝马车生产配件
public class 宝马工厂 implements AbstractFactory {    
    
     @Override    
    public Engine createEngine() {      
        return new EngineB();    
    }    
    @Override    
    public Aircondition createAircondition() {    
        return new AirconditionB();    
    }    
}

2.3.3. 分析

抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。