JAVA设计模式之---工厂模式

1、引言

工厂模式可以分为类： 
1）简单工厂模式（Simple Factory） 
2）工厂方法模式（Factory Method） 
3）抽象工厂模式（Abstract Factory） 
 这种模式从上到下逐步抽象，并且更具一般性，且通常将简单工厂模式看为工厂方法模式的一种特例，两者归为一类。 

2、区别 

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

抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类可以创建多个具体产品类的实例。   

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

3、示例

1）简单工厂模式

产品类：

public class BMW {
    public BMW() {
    }
}

public class BMWX1 extends BMW {
    public BMWX1() {
        System.out.println("this is BMW X1");
    }
}

public class BMWX7 extends BMW {
    public BMWX7() {
        System.out.println("this is BMW X7");
    }
}

工厂类：

public class BMWFactory {
    public BMW creatBMW(String type){
        if (type.equals("X1")) {
            return new BMWX1();
        } else if (type.equals("X7")) {
            return new BMWX7();
        } else {
            return null;
        }
    }
}

客户类：

public class Customer {
    public static void main(String[] args) {
        BMWFactory factory = new BMWFactory();
        BMW X1 = factory.creatBMW("X1");
        BMW X7 = factory.creatBMW("X7");
    }
}

每增加一种车型，需增加一个if-else条件语句，违反了对扩展开放，对修改关闭原则

2）工厂方法模式：

产品类：

public class BMW {
    public BMW() {
    }
}

public class BMWX1 extends BMW {
    public BMWX1() {
        System.out.println("BMW X1");
    }
}

public class BMWX7 extends BMW {
    public BMWX7() {
        System.out.println("BMW X7");
    }
}

工厂类：

public interface BMWFactory {
    BMW createBMW();
}

public class BMWX1Factory implements BMWFactory {
    @Override
    public BMW createBMW() {
        return new BMWX1();
    }
}

public class BMWX7Factory implements BMWFactory {
    @Override
    public BMW createBMW() {
        return new BMWX7();
    }
}

客户类：

public class Customer {
    public static void main(String[] args) {
        BMWX1Factory x1 = new BMWX1Factory();
        x1.createBMW();

        BMWX7Factory x7 = new BMWX7Factory();
        x7.createBMW();
    }
}

客户程序中仅仅处理抽象产品角色提供的接口，但使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象。

 3）抽象工厂模式：

产品类：

public interface Engine {
}

public class EngineA implements Engine {
    public EngineA() {
        System.out.println("Engine A");
    }
}

public class EngineB implements Engine {
    public EngineB() {
        System.out.println("Engine B");
    }
}

public interface AirCondition {
}

public class AirConditionC implements AirCondition {
    public AirConditionC() {
        System.out.println("AirCondition C");
    }
}

public class AirConditionD implements AirCondition {
    public AirConditionD() {
        System.out.println("AirCondition D");
    }
}

工厂类：

public interface Abstractfactory {
    public Engine selectEngine();
    public AirCondition selectAirCondition();
}

public class FactoryBMWX1 implements Abstractfactory {
    @Override
    public Engine selectEngine() {
        return new EngineA();
    }

    @Override
    public AirCondition selectAirCondition() {
        return new AirConditionC();
    }
}

public class FactoryBMWX7 implements Abstractfactory{
    @Override
    public Engine selectEngine() {
        return new EngineB();
    }

    @Override
    public AirCondition selectAirCondition() {
        return new AirConditionD();
    }
}

客户类：

public class Customer {
    public static void main(String[] args) {
        FactoryBMWX1 x1 = new FactoryBMWX1();
        x1.selectEngine();
        x1.selectAirCondition();

        FactoryBMWX7 x7 = new FactoryBMWX7();
        x7.selectEngine();
        x7.selectAirCondition();
    }
}

提供多个工厂角色分别对应多个产品角色，每一个具体工厂角色只负责某一个产品角色的实例化，每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。

 4、总结

　　无论是哪种工厂模式，在形式和特点上也是极为相似的，最终目的都是为了解耦。在使用时，不必在意具体属于哪种模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。

转自：http://blog.csdn.net/jason0539