工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，定义一个创建对象的接口或抽象类，让其子类来决定实例化哪一个具体类。这样可以将对象的创建与使用分离开来，增加了系统的灵活性和可维护性。 例如，有一个产品接口，多个具体产品实现该接口，然后有一个工厂类，根据不同的条件来创建相应的具体产品对象。
优点包括：
- 解耦了产品的创建和使用。
- 方便扩展产品类，无需修改使用产品的代码。
- 可以集中管理对象的创建逻辑。
《设计模式》一书中，工厂模式被分为了三种：简单工厂、工厂方法和抽象工厂。（不过，在书中作者将简单工厂模式看作是工厂方法模式的一种特例。）
接下来我会介绍三种工厂模式的原理及使用
- 简单工厂模式（不属于GOF的23种经典设计模式）
- 工厂方法模式
- 抽象工厂模式
简单工厂：
在不考虑任何代码的可扩展性的前提下,只为了尽快满足需求.我们可以这样去设计这个业务的代码结构
interface Product {
void doSomething();
}
class ConcreteProductA implements Product {
@Override
public void doSomething() {
System.out.println("ConcreteProductA is doing something");
}
}
class ConcreteProductB implements Product {
@Override
public void doSomething() {
System.out.println("ConcreteProductB is doing something");
}
}
class SimpleFactory {
public Product createProduct(String type) {
if ("A".equals(type)) {
return new ConcreteProductA();
} else if ("B".equals(type)) {
return new ConcreteProductB();
}
return null;
}
}
public class SimpleFactoryExample {
public static void main(String[] args) {
// 不同的产品做什么事情
SimpleFactory factory = new SimpleFactory();
Product productA = factory.createProduct("A");
productA.doSomething();
Product productB = factory.createProduct("B");
productB.doSomething();
}
}
工厂方法模式：
为了提高代码扩展性,我们需要将简单工厂中的if分支逻辑去掉,通过增加抽象工厂(生产工厂的工厂)的方式,让具体工厂去进行实现,由具体工厂来决定实例化哪一个具体的产品对象.
interface Product {
void doSomething();
}
class ConcreteProductA implements Product {
@Override
public void doSomething() {
System.out.println("ConcreteProductA is doing something");
}
}
class ConcreteProductB implements Product {
@Override
public void doSomething() {
System.out.println("ConcreteProductB is doing something");
}
}
// 抽象工厂
abstract class Factory {
abstract Product createProduct();
}
//工厂A继承抽象工厂 **具体工厂**
class ConcreteFactoryA extends Factory {
@Override
Product createProduct() {
return new ConcreteProductA();
}
}
class ConcreteFactoryB extends Factory {
@Override
Product createProduct() {
return new ConcreteProductB();
}
}
public class FactoryMethodExample {
public static void main(String[] args) {
// 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程；
//在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，
//无须对原工厂进行任何修改，满足开闭原则；
Factory factoryA = new ConcreteFactoryA();
Product productA = factoryA.createProduct();
productA.doSomething();
Factory factoryB = new ConcreteFactoryB();
Product productB = factoryB.createProduct();
productB.doSomething();
}
}抽象工厂模式
在抽象工厂模式中,每一个具体工厂都提供了多个工厂方法,用于产生多种不同类型的产品.这些产品构成了一个产品族.
interface ProductA {
void doSomethingA();
}
interface ProductB {
void doSomethingB();
}
class ConcreteProductA1 implements ProductA {
@Override
public void doSomethingA() {
System.out.println("ConcreteProductA1 is doing something A");
}
}
class ConcreteProductA2 implements ProductA {
@Override
public void doSomethingA() {
System.out.println("ConcreteProductA2 is doing something A");
}
}
class ConcreteProductB1 implements ProductB {
@Override
public void doSomethingB() {
System.out.println("ConcreteProductB1 is doing something B");
}
}
class ConcreteProductB2 implements ProductB {
@Override
public void doSomethingB() {
System.out.println("ConcreteProductB2 is doing something B");
}
}
interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
class ConcreteFactory1 implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA1();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB1();
}
}
class ConcreteFactory2 implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA2();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB2();
}
}
public class AbstractFactoryExample {
public static void main(String[] args) {
//对于不同产品系列有比较多共性特征时，可以使用抽象工厂模式，有助于提升组件的复用性.
//当需要提升代码的扩展性并降低维护成本时，把对象的创建和使用过程分开，
// 能有效地将代码统一到一个级别上
//解决跨平台带来的兼容性问题
AbstractFactory factory1 = new ConcreteFactory1();
ProductA productA1 = factory1.createProductA();
ProductB productB1 = factory1.createProductB();
productA1.doSomethingA();
productB1.doSomethingB();
AbstractFactory factory2 = new ConcreteFactory2();
ProductA productA2 = factory2.createProductA();
ProductB productB2 = factory2.createProductB();
productA2.doSomethingA();
productB2.doSomethingB();
}
}
抽象工厂模式比工厂方法模式的抽象程度更高. 在工厂方法模式中每一个具体工厂只需要生产一种具体产品,但是在抽象工厂模式中一个具体工厂可以生产一组相关的具体产品,这样一组产品被称为产品族.产品族中的每一个产品都分属于某一个产品继承等级结构.
在使用工厂模式时候需要注意：
简单工厂模式：
- 工厂类可能会变得庞大和复杂，当产品种类较多时维护成本可能增加。
- 不利于扩展新的产品类型，如果添加新产品可能需要修改工厂类。
工厂方法模式：
- 可能会导致系统中类的数量增多，增加一定的复杂性。
- 对于每个具体工厂类，需要确保其创建逻辑的正确性和稳定性。
抽象工厂模式：
- 难以应对产品族结构的频繁变化，扩展较为困难。
- 增加新的产品族可能需要较大的改动。
总体来说，无论哪种工厂模式，都需要在设计时充分考虑系统的扩展性、可维护性和灵活性，根据具体需求合理选择和运用。同时，要注意保持代码的清晰和简洁，避免过度设计导致不必要的复杂性。
