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

巴特西

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

最新文章

热门文章