工厂方法模式 - 简单工厂模式 - 抽象工厂模式

1.概述

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

针对的问题

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

那怎样能够方便的构建对象实例，而不关心构造对象实例的细节和复杂过程呢，那就是建立一个工厂来创建对象，把创建的过程封装到工厂中。

工厂模式类型

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

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

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

三种工厂模式特征及实现

简单工厂模式

角色组成

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

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

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

具体实现

1.产品类

abstract class BMW{
    public BMW(){}
}

2.具体产品类

//具体产品类
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");
   }
}

3.工厂类

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

分析

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

工厂方法模式

角色构成

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

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

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

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

实现

//抽象产品类
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的工厂(省略了两个工厂)。都实现了工厂的接口

分析

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

抽象工厂模式

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

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

角色构成

实现代码

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

分析

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