Java设计模式-工厂模式（简单工厂+工厂方法）

1、概念

工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的，简单说就是调用工厂里的方法来生产对象(产品)的。

工厂模式可以分为三类：

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

2、代码实现

1、简单工厂模式

简单工厂模式又称静态工厂方法模式，它存在的目的很简单：定义一个用于创建对象的接口。

先来看看它的组成：
（1）工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品；
（2）抽象产品角色：它一般是具体产品继承的父类或者实现的接口；
（3）具体产品角色：工厂类所创建的对象就是此角色的实例，在Java中由一个具体类实现；

/**
* 产品类
*/

abstract class BMW {  
    public BMW(){  

    }  
}  

public class BMW320 extends BMW {  
    public BMW320() {  
        System.out.println("制造-->BMW320");  
    }  
}  
public class BMW523 extends BMW{  
    public BMW523(){  
        System.out.println("制造-->BMW523");  
    }  
}  

/**
* 工厂类
*/
public class Factory {  
    //简单工厂
    public BMW createBMW(int type) {  
        switch (type) {   
        case 320:  
            return new BMW320();  
            break;

        case 523:  
            return new BMW523();  
        }  
        return null;  
    } 

    //静态工厂
    public static BMW createSBMW(int type) {  
        switch (type) {   
        case 320:  
            return new BMW320();  
            break;

        case 523:  
            return new BMW523();  
        }  
        return null;  
    }  
}  

//测试类
public class Customer {  
    public static void main(String[] args) {  

        Factory factory = new Factory();  
        BMW bmw320 = factory.createBMW(320);  
        BMW bmw523 = factory.createBMW(523);  

        BMW sbmw320 = Factory.createSBMW(320);
        BMW sbmw523 = Factory.createSBMW(523); 
    }  
}

我们从开闭原则（对扩展开放、对修改封闭）上来分析下简单工厂模式，我们每增加一种新类型，都要在工厂类中增加相应的创建业务逻辑（createBMW(int type)方法需要新增case），这显然是违背开闭原则的。这种情况下我们就需要使用工厂方法模式了，将工厂类定义成接口，而每新增一种类型，就增加该车种类型对应工厂类的实现，这样工厂的设计就可以扩展了，而不必去修改原来的代码。

2、工厂方法模式

工厂方法模式组成：
（1）抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
（2）具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
（3）抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
（4）具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

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

    }  
}  
public class BMW320 extends BMW {  
    public BMW320() {  
        System.out.println("制造-->BMW320");  
    }  
}  
public class BMW523 extends BMW{  
    public BMW523(){  
        System.out.println("制造-->BMW523");  
    }  
}  

//工厂类
interface FactoryBMW {  
    BMW createBMW();  
}  

public class FactoryBMW320 implements FactoryBMW{  

    @Override  
    public BMW320 createBMW() {  

        return new BMW320();  
    }  

}  
public class FactoryBMW523 implements FactoryBMW {  
    @Override  
    public BMW523 createBMW() {  

        return new BMW523();  
    }  
}

//测试类
public class Customer {  
    public static void main(String[] args) {  
        FactoryBMW320 factoryBMW320 = new FactoryBMW320();  
        BMW320 bmw320 = factoryBMW320.createBMW();  

        FactoryBMW523 factoryBMW523 = new FactoryBMW523();  
        BMW523 bmw523 = factoryBMW523.createBMW();  
    }  
}  

工厂方法模式仿佛已经很完美的对对象的创建进行了包装，但当产品种类非常多时，会出现大量的与之对应的工厂对象。