个人博客
http://www.milovetingting.cn
工厂方法模式
模式介绍
工厂方法模式是创建型设计模式之一。
模式定义
定义一个用于创建对象的接口，让子类决定实例化哪个类。
使用场景
在任何需要生成复杂对象的地方，都可以使用工厂方法模式。用new就可以完成创建的对象无需使用工厂方法模式。
简单实现
定义抽象类Product
1
2
3
4
5
6
7
8
| public abstract class Product {
public abstract void method();
}
|
定义实现类ProductA,ProductB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| public class ProductA extends Product {
@Override
public void method() {
System.out.println("productA:method");
}
}
public class ProductB extends Product {
@Override
public void method() {
System.out.println("productB:method");
}
}
|
定义抽象工厂Factory
1
2
3
4
5
6
7
8
9
10
| public abstract class Factory {
public abstract Product createProduct();
}
|
定义实现类FactoryA,FactoryB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| public class FactoryA extends Factory {
@Override
public Product createProduct() {
return new ProductA();
}
}
public class FactoryB extends Factory {
@Override
public Product createProduct() {
return new ProductB();
}
}
|
调用
1
2
3
4
5
| public static void main(String[] args) {
Factory factory = new FactoryA();
Product product = factory.createProduct();
product.method();
}
|
输出:
1
2
3
4
5
| public static void main(String[] args) {
Factory factory = new FactoryB();
Product product = factory.createProduct();
product.method();
}
|
输出:
这种方式，在Product的子类增加的时候，需要增加Product的实现以及Factory的实现。可以利用反射的方式更简洁地扩展,增加Product的子类时，不需要再增加Factory的子类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| public abstract class AbstractFactory {
public abstract <T extends Product> T createProduct(Class<T> clz);
}
public class FactoryImpl extends AbstractFactory {
@Override
public <T extends Product> T createProduct(Class<T> clz) {
Product product = null;
try {
product = (Product) Class.forName(clz.getName()).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return (T) product;
}
}
|
调用
1
2
3
4
5
| public static void main(String[] args) {
AbstractFactory factory = new FactoryImpl();
Product product = factory.createProduct(ProductA.class);
product.method();
}
|
输出结果:
调用
1
2
3
4
5
| public static void main(String[] args) {
AbstractFactory factory = new FactoryImpl();
Product product = factory.createProduct(ProductB.class);
product.method();
}
|
输出结果:
小结
总的来说，工厂方法模式是一个很好的设计模式，但是缺点也是难以避免的，每次我们为工厂方法模式添加新的产品时就要编写一个新的产品类，同时还要引入抽象层，这必然会导致类结构的复杂化，所以在某些情况比较简单时，是否要使用工厂方法 模式，需要设计者权衡利弊。
