目录
1.简介
定义一个用于创建对象的接口,让子类去决定到底哪个类需要实例化。通过工厂方法使得一个类的实例化从而延迟到子类。这样我们通过依赖抽象接口创建出具体的实例,避免变化所带来的影响,这也正符合DIP。
2.优点
具有良好的封装性和扩展性。
3.形式
抽象产品
public abstract class AProduct {
public void method1(){}
public void method2(){}
}
具体产品1
public class Product extends Aproduct {
public void method1(){}
}
具体产品2
public class Product2 extends Aproduct {
public void method2(){}
}
抽象工厂
public abstract class AFactory {
public abstract <T extends AProduct> T makeProduct(Class<T> p);
}
具体工厂
public class Factory extends AFactory {
public <T extends AProduct> T makeProduct(Class<T> p) {
Product product = null;
try {
product = (Product) Class.forName(p.getName()).newInstance();
}catch(Exception e) {
System.out.println("创建失败");
}
return (T)product;
}
}
工厂生产产品
public class FacotryCreateProduct {
public static void main(String[] args) {
Factory factory = new Factory();
AProduct product1 = factory.makeProduct(Product1.class);
AProduct product2 = factory.makeProduct(Product2.class);
}
}
4.扩展
一个优秀的模式总会衍生出许多扩展形式,如简单工厂模式,又叫静态工厂模式。从中我们可以知道它基本是利用静态方法实现创建
public class Factory {
public static <T extends Human> T makeProduct(Class<T> p) {
Product product = null;
try {
product = (Product)Class.forName(p.getName()).newInstance();
}catch(Exception e) {
System.out.println("创建失败");
}
}
}
这样就可以不用先把Factory生成出来,直接使用Factory.makeProduct(Product1.class);即可。
当一个对象经常被反复调用时,不会立即被释放,而是会先缓存起来,等待下次的调用,这便是延迟工厂模式
public class Factory {
private static final Map<String, Product> productMap = new HashMap();
public static synchronized Product makeProduct(String name) throws Exception{
Product product = null;
if(productMap.containsKey(name)) {
product = productMap.get(name);
}else {
if(name.equals("Product1")) {
product = new Product1();
}else{
product = new Product2();
}
publicMap.put(name, product);
}
return product;
}
}