设计模式之：工厂模式

工厂模式

工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。
工厂模式可以分为三类：
1）简单工厂模式（Simple Factory）
2）工厂方法模式（Factory Method）
3）抽象工厂模式（Abstract Factory）
这三种模式从上到下逐步抽象，并且更具一般性。

情景模拟+代码实现

现在有两款汽车分别是奔驰，宝马。称之为“产品”：

abstract class Car {    public Car() {    }}public class BenzCar extends Car {    public BenzCar() {        System.out.println("奔驰汽车！");    }}public class BMWCar extends Car {    public BMWCar() {        System.out.println("宝马汽车！");    }}

有了产品当然需要客户了。

1.无工厂模式

现在有“客户”需要使用汽车，但是没有工厂怎么办？
没办法，只能自己动手，丰衣足食。

public class Main {    public static void main(String[] args) {        Car car1 = new BenzCar();//制造奔驰汽车        Car car2 = new BMWCar();//制造宝马汽车    }}

用户需要什么汽车，只需要new一下，然后自己制造就行了。（当然我们不用管他是怎么制造汽车的）
没有工厂时代的客户真的惨，需要什么汽车还要自己制造。~.~

2.简单工厂模式（Simple Factory）

然后有人发现制造汽车有利可图，建立了汽车工厂，生产汽车。然后向客户宣布：“你们给我下订单，你给我钱，我帮你们制造想要的汽车”！

public class SimpleFactory {    /**     * 1.生产奔驰汽车 2.生产宝马汽车     *     * @return     */    public Car create(int type) {        switch (type) {            case 1:                return new BenzCar();            case 2:                return new BMWCar();            default:                break;        }        return null;    }}

客户喜闻乐见，这下买汽车可方便多了。只需要找到工厂下订单就行。

public class Main {    public static void main(String[] args) {        SimpleFactory factory = new SimpleFactory();//找到工厂        factory.create(1);//下订单制造奔驰汽车        factory.create(2);//下订单制造宝马汽车    }}

3.工厂方法模式（Factory Method）

汽车给人们带来极大的便利，然后汽车的需求量越来越大,汽车的类型也越来越多。
一个工厂无法制造多种类型的汽车，也已经无法满足当前的需求量了怎么办？
开“分厂”，每个分厂制造只制造一种汽车，大大提升了效率！

interface Factory {    Car create();}//奔驰厂public class BenzFactory implements Factory {    @Override    public Car create() {        return new BenzCar();    }}//宝马厂public class BMWFactory implements Factory {    @Override    public Car create() {        return new BMWCar();    }}

需要奔驰车的去奔驰厂，需要宝马车的去宝马厂。

public class Main {    public static void main(String[] args) {        Factory factory = new BenzFactory();        factory.create();        Factory factory1 = new BMWFactory();        factory1.create();    }}

4.抽象工厂模式（Abstract Factory）

时代在进步，汽车制造也要进步。现在汽车需要装空调了！
但是空调也有两个品牌：海尔，美的。

public interface Aircondition {}public class HaierAircondition implements Aircondition {    public HaierAircondition(){        System.out.println("+装配海尔空调！");    }}public class MeiderAircondition implements Aircondition{    public MeiderAircondition() {        System.out.println("+装配美的空调！");    }}

奔驰车装海尔空调，宝马汽车装美的空调！
工厂升级为可装空调的厂！

public interface AbstractFactory {    Car car();    Aircondition aircondition();}public class BenzHaierFactory implements AbstractFactory {    @Override    public Car car() {        return new BenzCar();    }    @Override    public Aircondition aircondition() {        return new HaierAircondition();    }}public class BMWMeiderFactory implements AbstractFactory {    @Override    public Car car() {        return new BMWCar();    }    @Override    public Aircondition aircondition() {        return new MeiderAircondition();    }}

然而并不是每个客户都买的起空调车：

public class Main {    public static void main(String[] args) {  AbstractFactory factory = new BenzHaierFactory();        factory.car();//购买奔驰汽车        factory.aircondition();//带空调的        AbstractFactory factory1 = new BMWMeiderFactory();        factory1.car();//购买宝马汽车        factory1.aircondition();//待美的空调的        AbstractFactory factory2= new BMWMeiderFactory();        factory2.car();//购买宝马汽车        //factory1.aircondition();//不需要空调的    }}

5.比较：

工厂方法模式：

1. 一个抽象产品类，可以派生出多个具体产品类。
2. 一个抽象工厂类，可以派生出多个具体工厂类。
3. 每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：

1. 多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
2. 一个抽象工厂类，可以派生出多个具体工厂类。
3. 每个具体工厂类可以创建多个具体产品类的实例。

区别：

1. 工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
2. 工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

总结

1. 传统的无工厂模式下，客户调用方法（购买汽车），就必须知道方法的内部实现细节（汽车的制造工艺）。这对客户来说无疑是痛苦的。
2. 而在简单工厂模式下，客户调用方法（购买汽车），只需要告诉方法类（工厂）自己需要哪种方法（汽车），无需知道方法的内部实现细节（汽车的制造工艺）。
3. 工厂方法模式下，客户只需要找到相应的类（工厂），就能调用相应的方法（购买汽车），极大的方便了客户，提高了效率。然而其需要的类（工厂）根据需求是不断增加的，对应前期的代码投入(工厂投资，建厂)消耗是很大的，并不是完美的。
4. 抽象工厂模式下，一个类运行有多个方法了（工厂可以同时汽车和空调），我们可以随意调用类中有关联的方法（汽车是否有空调）。虽然看似与工厂方法类似，但是其实现细节与内存还是有很大差异的。

工厂方法模式仿佛已经很完美的对对象的创建进行了包装，使得客户程序中仅仅处理抽象产品角色提供的接口，但使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。
抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。
工厂方法模式是继承自一个抽象类，子类去实现某一个工厂方法，将对象生产延迟到子类中。而抽象工厂模式，一般是实现一个抽象工厂的接口，由具体的工厂去实现相应的接口，可以这样说吧，抽象工厂模式是包含工厂方法模式的。

代码下载

本文设计的Java代码：
http://download.csdn.net/download/demonliuhui/9957341

参考：

http://blog.csdn.net/lemon_tree12138/article/details/46225213