工厂方法模式（Factory Pattern）是创建型设计模式之一。如 Android 中的 Activity 里的各个生命周期方法，以 onCreate 方法为例，它就可以看作是一个工厂方法，我们在其中可以构造我们的 View，并通过 setContentView 返回给 framework 处理等。
定义
定义一个用于创建对象的接口，让子类决定实例化哪个类。工厂方法让类的实例化推迟到子类中进行。
适用场景
在任何需要生成复杂对象的地方，都可以使用工厂方法模式。复杂对象适合使用工厂模式，用 new 就可以完成创建的对象无需使用工厂模式。
- 创建对象需要大量重复代码
- 客户端（应用层）不依赖于产品类实例如何被创建、实现等细节
- 一个类通过其子类来指定创建哪个对象
优点
- 用户只需要关心所需产品对应的工厂，无需关心创建细节
- 加入新产品符合开闭原则，提高可扩展属性
缺点
- 类的个数容易过多，增加复杂度
- 增加了系统的抽象性和理解难度
工厂方法模式的 UML 类图
UML 类图如图 1-1 所示。
图 1-1
根据图 1-1可以得出一个工厂方法模式的通用模式代码。
public abstract class Product {
/**
* 产品类的抽象方法，由具体的产品类去实现
*/
public abstract void method();
}
//具体产品A
public class ConcreteProductA extends Product {
@Override
public void method() {
System.out.println("具体的产品 A");
}
}
//具体产品B
public class ConcreteProductB extends Product {
@Override
public void method() {
System.out.println("具体的产品 B");
}
}
//抽象工厂类
public abstract class Factory {
/**
* 抽象工厂方法
* 具体生产什么由子类去实现
*
* @return 具体的产品对象
*/
public abstract Product createProduct();
}
//具体工厂类
public class ConcreteFactory extends Factory {
@Override
public Product createProduct() {
return new ConcreteProductA();
}
}
//客户类
public class Client {
public static void main(String[] args) {
Factory factory = new ConcreteFactory();
Product product = factory.createProduct();
product.method();
}
}
主要分为四大模块，一是抽象工厂，其为工厂方法模式的核心；二是具体工厂，其实现了具体的业务逻辑；三是抽象产品，是工厂方法模式所创建的产品的父类；四是具体产品，为实现抽象产品的某个具体产品的对象。
上诉代码中在 Client 类中构造了一个工厂对象，并通过其生产了一个产品对象。这里得到的产品对象是 ConcreteProductA 的实例，如果要得到 ConcreteProductB 的实例，更改 ConcreteFactory 中的逻辑即可。
//具体工厂类
public class ConcreteFactory extends Factory {
@Override
public Product createProduct() {
return new ConcreteProductB();
//return new ConcreteProductA();
}
}
这种方式比较常见，需要哪一个产品就生产哪一个，有时候也可以利用反射的方式更简洁的来生产具体产品对象，此时，需要在工厂方法的参数列表中传入一个 Class 类来决定是哪一个产品类。
public abstract class Factory {
/**
* 抽象工厂方法
* 具体生产什么由子类去实现
*
* @param clz 产品对象类型
* @return 具体的产品对象
*/
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 product = null;
try {
product = (Product) Class.forName(clz.getName()).newInstance();
} catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
e.printStackTrace();
}
return (T) product;
}
}
最后看看 Client 类中的实现。
public class Client {
public static void main(String[] args) {
Factory factory = new ConcreteFactory();
Product product = factory.createProduct(ConcreteProductA.class);
product.method();
}
}
需要哪一个类的对象就传入哪一个类的类型即可，这种方法比较简洁、动态。也可以为每一个产品都定义一个具体的工厂类，各司其职。
public class ConcreteProductA extends Product {
@Override
public void method() {
System.out.println("具体的产品 A");
}
}
public class ConcreteProductB extends Product {
@Override
public void method() {
System.out.println("具体的产品 B");
}
}
public class Client {
public static void main(String[] args) {
Factory factoryA = new ConcreteFactoryA();
Product productA = factoryA.createProduct();
productA.method();
Factory factoryB = new ConcreteFactoryB();
Product productB = factoryB.createProduct();
productB.method();
}
}
像这样拥有多个工厂的方式我们称为多工厂方法模式。
小结
总的来说，工厂方法模式是一个很好的设计模式，但是缺点也是难以避免的，每次我们为工厂方法模式添加新的产品时就要编写一个新的产品类，同时还有引入抽象层，这必然导致类结构的复杂化。
网友评论