简单工厂模式

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

分类：

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

简单工厂分为：

　　简单工厂：不仅可以利用简单工厂来创建接口，也可以用简单工厂来创造抽象类，甚至是一个具体的实例。

　　静态工厂：没有创建工厂实例的必要，把简单工厂实现成一个工具类，直接使用静态方法。

　　万能工厂：一个简单工厂可以包含很多用来构造东西的方法，这些方法可以创建不同的接口、抽象类或者是类实例。

简单工厂模式：

　　建立一个工厂（一个函数或一个类方法）来制造新的对象。

简单工厂的优缺点：

　　优点：封装、解耦。

　　缺点：增加客户端复杂化、不便于扩展子工厂。

角色：

　　1.工厂类

01.public class Factory {  
02.    public BMW createBMW(int type) {  
03.        switch (type) {  
04.          
05.        case 320:  
06.            return new BMW320();  
07.  
08.        case 523:  
09.            return new BMW523();  
10.  
11.        default:  
12.            break;  
13.        }  
14.        return null;  
15.    }  
16.}

　　2.产品类

01.abstract class BMW {  
02.    public BMW(){  
03.          
04.    }  
05.}  
06.  
07.public class BMW320 extends BMW {  
08.    public BMW320() {  
09.        System.out.println("制造-->BMW320");  
10.    }  
11.}  
12.public class BMW523 extends BMW{  
13.    public BMW523(){  
14.        System.out.println("制造-->BMW523");  
15.    }  
16.}  

　　3.客户类

01.public class Customer {  
02.    public static void main(String[] args) {  
03.        Factory factory = new Factory();  
04.        BMW bmw320 = factory.createBMW(320);  
05.        BMW bmw523 = factory.createBMW(523);  
06.    }  
07.}  

工厂方法模式：

　　工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。 

角色：

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

　　产品类

01.abstract class BMW {  
02.    public BMW(){  
03.          
04.    }  
05.}  
06.public class BMW320 extends BMW {  
07.    public BMW320() {  
08.        System.out.println("制造-->BMW320");  
09.    }  
10.}  
11.public class BMW523 extends BMW{  
12.    public BMW523(){  
13.        System.out.println("制造-->BMW523");  
14.    }  
15.}  

　　工厂类

01.interface FactoryBMW {  
02.    BMW createBMW();  
03.}  
04.  
05.public class FactoryBMW320 implements FactoryBMW{  
06.  
07.    @Override  
08.    public BMW320 createBMW() {  
09.  
10.        return new BMW320();  
11.    }  
12.  
13.}  
14.public class FactoryBMW523 implements FactoryBMW {  
15.    @Override  
16.    public BMW523 createBMW() {  
17.  
18.        return new BMW523();  
19.    }  
20.}  

　　客户类

01.public class Customer {  
02.    public static void main(String[] args) {  
03.        FactoryBMW320 factoryBMW320 = new FactoryBMW320();  
04.        BMW320 bmw320 = factoryBMW320.createBMW();  
05.  
06.        FactoryBMW523 factoryBMW523 = new FactoryBMW523();  
07.        BMW523 bmw523 = factoryBMW523.createBMW();  
08.    }  
09.}  

抽象工厂模式

　　当每个抽象产品都有多于一个的具体子类的时候（空调有型号A和B两种，发动机也有型号A和B两种），工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产品角色都有两个具体产品（产品空调有两个具体产品空调A和空调B）。抽象工厂模式提供两个具体工厂角色（宝马320系列工厂和宝马230系列工厂），分别对应于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。

　　产品类

01.//发动机以及型号    
02.public interface Engine {    
03.  
04.}    
05.public class EngineA extends Engine{    
06.    public EngineA(){    
07.        System.out.println("制造-->EngineA");    
08.    }    
09.}    
10.public class EngineBextends Engine{    
11.    public EngineB(){    
12.        System.out.println("制造-->EngineB");    
13.    }    
14.}    
15.  
16.//空调以及型号    
17.public interface Aircondition {    
18.  
19.}    
20.public class AirconditionA extends Aircondition{    
21.    public AirconditionA(){    
22.        System.out.println("制造-->AirconditionA");    
23.    }    
24.}    
25.public class AirconditionB extends Aircondition{    
26.    public AirconditionB(){    
27.        System.out.println("制造-->AirconditionB");    
28.    }    
29.}   

　　工厂类

01.//创建工厂的接口    
02.public interface AbstractFactory {    
03.    //制造发动机  
04.    public Engine createEngine();  
05.    //制造空调   
06.    public Aircondition createAircondition();   
07.}    
08.  
09.  
10.//为宝马320系列生产配件    
11.public class FactoryBMW320 implements AbstractFactory{    
12.        
13.    @Override    
14.    public Engine createEngine() {      
15.        return new EngineA();    
16.    }    
17.    @Override    
18.    public Aircondition createAircondition() {    
19.        return new AirconditionA();    
20.    }    
21.}    
22.//宝马523系列  
23.public class FactoryBMW523 implements AbstractFactory {    
24.    
25.     @Override    
26.    public Engine createEngine() {      
27.        return new EngineB();    
28.    }    
29.    @Override    
30.    public Aircondition createAircondition() {    
31.        return new AirconditionB();    
32.    }    33.}   

　　客户类

01.public class Customer {    
02.    public static void main(String[] args){    
03.        //生产宝马320系列配件  
04.        FactoryBMW320 factoryBMW320 = new FactoryBMW320();    
05.        factoryBMW320.createEngine();  
06.        factoryBMW320.createAircondition();  
07.            
08.        //生产宝马523系列配件    
09.        FactoryBMW523 factoryBMW523 = new FactoryBMW523();    
10.        factoryBMW320.createEngine();  
11.        factoryBMW320.createAircondition();  
12.    }    
13.}  

总结：

工厂方法模式：
　　一个抽象产品类，可以派生出多个具体产品类。
　　一个抽象工厂类，可以派生出多个具体工厂类。
　　每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：
　　多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
　　一个抽象工厂类，可以派生出多个具体工厂类。
　　每个具体工厂类可以创建多个具体产品类的实例。
区别：
　　工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
　　工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
两者皆可。