定义
工厂方法模式(Factory Method)
定义一个用于创建对象的接口,让子类决定实例化哪一个类。 Factory Method使一个类的实例化延迟到其子类。
从定义中就可以看出这个模式的作用:定义和维护对象之间的关系。
工厂方法模式的适用场景有:
- 当一个类不知道它所必须创建的对象的类的时候。
- 当一个类希望由它的子类来指定它所创建的对象的时候。
- 当类将创建对象的职责委托给多个帮助子类中的某一个,并且你希望将哪一个帮助子类 是代理者这一信息局部化的时候。
它的类图可以参考下图:
其中
- Product —定义工厂方法所创建的对象的接口。
- ConcreteProduct —实现Product接口。
- Creator —声明工厂方法,该方法返回一个Product类型的对象。Creator也可以定义一个工厂方法的缺省实现,它返回一个缺省的ConcreteProduct对象。也可以调用工厂方法以创建一个Product对象。
- ConcreteCreator —重定义工厂方法以返回一个ConcreteProduct实例
实现
下面通过对代码实现上面描述的工厂方法模式。
根据类图,先定义一个产品的接口。
package com.designpattern.creational.factoryMethod;
/**
* — 定义工厂方法所创建的对象的接口。
* Created by mungo on 2017/3/29.
*/
public interface Product {
public void getProductName();
public void getProductColor();
}
产品接口Product ,是产品的一个抽象,每个产品定义两个方法,输出产品名称和颜色。
然后定义两个个具体产品ConcreteProductA 和ConcreteProductB。
package com.designpattern.creational.factoryMethod;
/**
* 实现Product接口。
* Created by mungo on 2017/3/29.
*/
public class ConcreteProductA implements Product {
@Override
public void getProductName() {
System.out.println("ProductA");
}
@Override
public void getProductColor() {
System.out.println("ProductA 红色");
}
}
package com.designpattern.creational.factoryMethod;
/**
* 实现Product接口。
* Created by mungo on 2017/3/29.
*/
public class ConcreteProductB implements Product {
@Override
public void getProductName() {
System.out.println("ProductB");
}
@Override
public void getProductColor() {
System.out.println("ProductB 白色");
}
}
这样需要的产品就定义好了,可是定义产品最终目的是为了使用,现在产品定义完成剩下的就是如何使用。想象一下,作为一个生产的管理者,如果每生产一个产品都要详细的知道产品的具体内容,这无疑是不 现实的。他应该只需要知道生产的是什么就可以了。所以,生产者应该接收产品的接口的实现类,然后去创建相应对象就好。
package com.designpattern.creational.factoryMethod;
/**
* 声明工厂方法,该方法返回一个Product类型的对象。
* Creator也可以定义一个工厂方法的缺省实现,
* 它返回一个缺省的ConcreteProduct对象。
* 可以调用工厂方法以创建一个Product对象。
* Created by mungo on 2017/3/29.
*/
public abstract class Creator {
public abstract <T extends Product> T createProduct(Class<T> c);
}
这里使用了泛型,这样通过对createProduct的输入参数做了两层限制:
- 必须为Class类型
- 必须是Product的实现类
通过这些约束可以减少类型的转换,同时可以约束其输入参数。
现在工厂定义好了,我们可以通过继承这个Creator 实现在使用时具体创建哪个类。当然也可以在里面定义一个缺省的实现,这些都是实现上的细节了。
package com.designpattern.creational.factoryMethod;
/**
* 重定义工厂方法以返回一个ConcreteCreator实例。
* Created by mungo on 2017/3/29.
*/
public class ConcreteCreator extends Creator {
@Override
public <T extends Product> T createProduct(Class<T> c) {
Product product = null;
try {
product = (Product) Class.forName(c.getName()).newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return (T) product;
}
}
这样通过传进来的Class名称就可以直接决定去创建哪个具体的类。
客户端代码如下:
package com.designpattern.creational.factoryMethod;
/**
* Created by mungo on 2017/3/29.
*/
public class Client {
public static void main(String[] args){
Creator factory = new ConcreteCreator();
Product productA= factory.createProduct(ConcreteProductA.class);
Product productB= factory.createProduct(ConcreteProductB.class);
productA.getProductName();
productA.getProductColor();
productB.getProductName();
productB.getProductColor();
}
}
输出结果:
这样,就实现了上面类图中的工厂方法模式。
可以看出,
工厂方法不再将与特定应用有关的类绑定到你的代码中。代码仅处理Product接口;因此它可以与用户定义的任何ConcreteProduct类一起使用。工厂方法的一个潜在缺点在于客户可能仅仅为了创建一个特定的ConcreteProduct对象,就不得不创建Creator的子类。当Creator子类不必需时,客户现在必然要处理类演化的其他方面;但是当客户无论如何必须创建Creator的子类时,创建子类也是可行的。
应用
工厂方法模式的有点
- 良好的封装性,同时可以为对象的创建提供一定的约束,使得调用者只需要知道这个对象的名称(或者其他的约束名称)即可。不需要去了解对象的创建过程,这可以降低模块之间的耦合。
- 扩展性好。如果现在要增加ConcreteProductC,在上面的代码中,只需要定义一个ConcreteProductC类即可。
- 屏蔽具体实现。就像上面的代码中,调用者无需关心ConcreteProductA,ConcreteProductB如何变化,只要Product的接口不变,调用者的使用方式就不会变化。因为实现类的实例化是由工厂完成的。
所以,工厂方法是典型的解耦框架。高层模块只需要知道抽象,对于其他的实现类都无需关系,这也符合面向对象的迪米特法则,即不需要去交流。同时,对象的创建不再由调用者,而是由框架去完成,调用只依赖具体实现的抽象,也符合依赖倒置原则。
对于工厂方法的应用,首先,工厂方法模式是为了创建对象替换new的一个替换方案,所以在需要创建对象的地方都可以使用,只是需要考虑引入一个工厂类进行管理增加的代码复杂度是否值得。其次,需要灵活可扩展的框架时。因为对于面向对象,一切皆对象。比如设计一个数据库访问的程序,对于不同的数据库就可以采用工厂方法模式,在使用时通过传递不同的数据库区分来决定使用哪个数据库驱动。