工厂模式是一种创建型设计模式，它提供了一种在不指定具体类的情况下创建对象的方法。通过使用工厂模式，我们可以将对象的创建过程与使用过程分离，从而优化代码结构并提高复用性。工厂模式还具有灵活性和可扩展性的优点，使得系统更易于维护和升级。工厂模式是开发过程中不可或缺的利器。
在软件开发中，为了提高代码的可读性、可维护性和可扩展性，我们经常需要使用一些设计模式，工厂模式是一种非常实用的设计模式，它通过定义一个创建对象的接口，让子类决定实例化哪一个类，本文将详细介绍工厂模式的原理、优缺点以及在实际开发中的应用。
1、工厂模式简介
工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种创建对象的最佳方式，在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，而是使用一个共同的接口来指向新创建的对象。
2、工厂模式的原理
工厂模式的主要目的是将对象的创建过程封装起来，使得客户端不需要关心对象是如何创建的，只需要关心如何获取到所需的对象，工厂模式的核心思想是通过抽象工厂类和具体工厂类来实现对象的创建。
工厂模式的基本结构如下：
- 抽象产品：定义了产品的规范，描述了产品的主要特性和功能。
- 具体产品：实现了抽象产品的具体类。
- 抽象工厂：提供了创建产品的接口，负责创建具体产品的对象。
- 具体工厂：实现了抽象工厂接口，负责生产具体产品的对象。
3、工厂模式的优点
- 提高代码的可读性：将对象的创建过程封装起来，客户端只需要关心如何获取到所需的对象，而不需要关心对象是如何创建的。
- 提高代码的可维护性：当需要修改对象的创建逻辑时，只需要修改具体工厂类的代码，而不需要修改客户端的代码。
- 提高代码的可扩展性：当需要添加新的具体产品时，只需要添加一个新的具体产品类和对应的具体工厂类，而不需要修改现有代码。
- 降低系统的耦合度：客户端不需要直接使用具体产品类，而是通过工厂类来创建对象，降低了系统各部分之间的耦合度。
4、工厂模式的缺点
- 增加了系统的复杂度：由于引入了抽象工厂类和具体工厂类，使得系统的代码变得更加复杂。
- 增加了系统的资源消耗：由于需要创建额外的工厂类，可能会增加系统的内存和CPU资源消耗。
5、工厂模式的应用场景
工厂模式适用于以下场景：
- 当需要创建的对象具有相同的属性和行为时，可以使用工厂模式来封装对象的创建过程。
- 当需要根据不同的条件创建不同的对象时，可以使用工厂模式来实现对象的动态创建。
- 当需要控制对象的创建过程，例如需要进行参数校验、权限检查等操作时，可以使用工厂模式来实现。
6、工厂模式的实现方式
工厂模式有多种实现方式，常见的有以下几种：
- 简单工厂模式：简单工厂模式是工厂模式的一种简化版，它只有一个具体工厂类，负责生产所有具体产品的对象，简单工厂模式适用于具体产品种类较少的场景。
// 抽象产品
public interface Product {
void doSomething();
}
// 具体产品A
public class ConcreteProductA implements Product {
@Override
public void doSomething() {
System.out.println("ConcreteProductA is doing something.");
}
}
// 具体产品B
public class ConcreteProductB implements Product {
@Override
public void doSomething() {
System.out.println("ConcreteProductB is doing something.");
}
}
// 具体工厂
public class ConcreteFactory {
public Product createProduct(String type) {
if (type.equals("A")) {
return new ConcreteProductA();
} else if (type.equals("B")) {
return new ConcreteProductB();
} else {
throw new IllegalArgumentException("Invalid product type: " + type);
}
}
}
// 客户端
public class Client {
public static void main(String[] args) {
ConcreteFactory factory = new ConcreteFactory();
Product productA = factory.createProduct("A");
productA.doSomething();
Product productB = factory.createProduct("B");
productB.doSomething();
}
}- 工厂方法模式：工厂方法模式是工厂模式的一种扩展，它定义了一个用于创建对象的接口，但由子类决定实例化哪一个类，工厂方法模式适用于具体产品种类较多，且每个具体产品都有自己独特的创建逻辑的场景。
// 抽象产品
public interface Product {
void doSomething();
}
// 具体产品A
public class ConcreteProductA implements Product {
@Override
public void doSomething() {
System.out.println("ConcreteProductA is doing something.");
}
}
// 具体产品B
public class ConcreteProductB implements Product {
@Override
public void doSomething() {
System.out.println("ConcreteProductB is doing something.");
}
}
// 抽象工厂
public abstract class AbstractFactory {
public abstract Product createProductA();
public abstract Product createProductB();
}
// 具体工厂A
public class ConcreteFactoryA extends AbstractFactory {
@Override
public Product createProductA() {
return new ConcreteProductA();
}
@Override
public Product createProductB() {
return new ConcreteProductB();
}
}
// 具体工厂B
public class ConcreteFactoryB extends AbstractFactory {
@Override
public Product createProductA() {
return new ConcreteProductA();
}
@Override
public Product createProductB() {
return new ConcreteProductB();
}
}
// 客户端
public class Client {
public static void main(String[] args) {
AbstractFactory factoryA = new ConcreteFactoryA();
Product productA = factoryA.createProductA();
productA.doSomething();
Product productB = factoryA.createProductB();
productB.doSomething();
AbstractFactory factoryB = new ConcreteFactoryB();
Product productC = factoryB.createProductA();
productC.doSomething();
Product productD = factoryB.createProductB();
productD.doSomething();
}
}- 抽象工厂模式：抽象工厂模式是工厂方法模式的进一步扩展，它提供了创建多个产品族的方法，抽象工厂模式适用于需要创建多个产品族的场景。
// 抽象产品A
public interface ProductA {
void doSomething();
}
// 抽象产品B
public interface ProductB {
void doSomething();
}
// 具体产品A1
public class ConcreteProductA1 implements ProductA {
@Override
public void doSomething() {
System.out.println("ConcreteProductA1 is doing something.");
}
}
// 具体产品A2
public class ConcreteProductA2 implements ProductA {
@Override
public void doSomething() {
System.out.println("ConcreteProductA2 is doing something.");
}
}
// 具体产品B1
public class ConcreteProductB1 implements ProductB {
@Override
public void doSomething() {
System.out.println("ConcreteProductB1 is doing something.");
}
}
// 具体产品B2
public class ConcreteProductB2 implements ProductB {
@Override
public void doSomething() {
System.out.println("ConcreteProductB2 is doing something.");
}
}
// 抽象工厂A
public interface AbstractFactoryA {
ProductA createProductA();
ProductB createProductB();
}
// 具体工厂A1
public class ConcreteFactoryA1 implements AbstractFactoryA {
@Override
public ProductA createProductA() {
return new ConcreteProductA1();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB1();
}
}
// 具体工厂A2
public class ConcreteFactoryA2 implements AbstractFactoryA {
@Override
public ProductA createProductA() {
return new ConcreteProductA2();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB2();
}
}
// 客户端
public class Client {
public static void main(String[] args) {
AbstractFactoryA factoryA1 = new ConcreteFactoryA1();
ProductA productA1 = factoryA1.createProductA();
productA1.doSomething();
ProductB productB1 = factoryA1.createProductB();
productB1.doSomething();
