工厂模式的好处:
通过工厂模式可以将产品的实例化封装起来,调用者不需要关心产品的实例化过程,方便了当开发者对产品的实例化进行修改时,不需让调用者参与。
抽象产品类:
public abstract class Product {
public abstract void color();
}
具体产品类A:
public class ConcretePrductA extends Product{
@Override
public void color() {
System.out.println("红色");
}
}
具体产品类B:
public class ConcretePrductB extends Product{
@Override
public void color() {
System.out.println("绿色");
}
}
抽象工厂类
public abstract class Factory {
public abstract <T extends Product> T createProduct(Class<T> clz);
}
具体工厂类
public class ConcreteFactory extends Factory{
@Override
public <T extends Product> T createProduct(Class<T> clz) {
Product p = null;
try{
p = (Product) Class.forName(clz.getName()).newInstance();
}catch (Exception e){
e.printStackTrace();
}
return (T)p;
}
}
上述代码我们通过利用反射来更简洁的生产具体产品对象,只需要在工厂方法的参数列表中传入一个Class类就可以决定究竟是要哪一个产品。
调用方式:
Factory factory = new ConcreteFactory();
Product p = factory.createProduct(ConcretePrductA.class);
p.color();
除了该种方法还可以通过创建多个具体工厂来生产具体产品,即多工厂方法模式。
public class ConcreteFactoryA extends Factory{
@Override
public Product createProduct() {
return new ConcretePrductA();
}
}
public class ConcreteFactoryB extends Factory{
@Override
public Product createProduct() {
return new ConcretePrductB();
}
}
Factory factoryA = new ConcreteFactoryA();
Product pA = factoryA.createProduct();
pA.color();
Factory factoryB = new ConcreteFactoryB();
Product pB = factoryB.createProduct();
pB.color();
另外如果确定只需一个工厂类,可以写为:
public class Factory{
public <T extends Product> T createProduct(Class<T> clz) {
Product p = null;
try{
p = (Product) Class.forName(clz.getName()).newInstance();
}catch (Exception e){
e.printStackTrace();
}
return (T)p;
}
}
该种方法即为简单工厂模式。