KEEP ON CODING......

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

posted @ 2016-06-06 15:42  Cecil2020  阅读(174)  评论(0编辑  收藏  举报