工厂模式（Factory Pattern）是一种创建型设计模式，它提供了创建对象的最佳方式之一。工厂模式使用工厂类来创建对象，而不是通过直接调用构造函数来实例化对象。这样做的好处是可以将对象的创建和使用分离，提供更好的灵活性和可扩展性。
工厂模式主要分为三种类型：
-
简单工厂模式（Simple Factory Pattern）
-
工厂方法模式（Factory Method Pattern）
-
抽象工厂模式（Abstract Factory Pattern）
1. 简单工厂模式
简单工厂模式通过一个工厂类，根据传入的参数决定创建哪种类型的实例。尽管简单工厂模式不是23种经典的设计模式之一，但它依然广泛使用。
示例代码：
java
// 产品接口
interface Product {
void use();
}
// 具体产品类A
class ConcreteProductA implements Product {
public void use() {
System.out.println("Using Product A");
}
}
// 具体产品类B
class ConcreteProductB implements Product {
public void use() {
System.out.println("Using Product B");
}
}
// 简单工厂类
class SimpleFactory {
public Product createProduct(String type) {
if (type.equals("A")) {
return new ConcreteProductA();
} else if (type.equals("B")) {
return new ConcreteProductB();
}
return null;
}
}
// 客户端代码
public class SimpleFactoryPatternDemo {
public static void main(String[] args) {
SimpleFactory factory = new SimpleFactory();
Product productA = factory.createProduct("A");
productA.use();
Product productB = factory.createProduct("B");
productB.use();
}
}2. 工厂方法模式
工厂方法模式定义了一个用于创建对象的接口，但由子类决定实例化哪一个类。工厂方法让一个类的实例化延迟到其子类。
java
示例代码：
// 产品接口
interface Product {
void use();
}
// 具体产品类A
class ConcreteProductA implements Product {
public void use() {
System.out.println("Using Product A");
}
}
// 具体产品类B
class ConcreteProductB implements Product {
public void use() {
System.out.println("Using Product B");
}
}
// 抽象工厂接口
interface Factory {
Product createProduct();
}
// 具体工厂类A
class ConcreteFactoryA implements Factory {
public Product createProduct() {
return new ConcreteProductA();
}
}
// 具体工厂类B
class ConcreteFactoryB implements Factory {
public Product createProduct() {
return new ConcreteProductB();
}
}
// 客户端代码
public class FactoryMethodPatternDemo {
public static void main(String[] args) {
Factory factoryA = new ConcreteFactoryA();
Product productA = factoryA.createProduct();
productA.use();
Factory factoryB = new ConcreteFactoryB();
Product productB = factoryB.createProduct();
productB.use();
}
}3. 抽象工厂模式
抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。它可以看作是工厂方法模式的进一步推广。
示例代码：
java
// 产品族接口
interface ProductA {
void use();
}
interface ProductB {
void eat();
}
// 具体产品类A1
class ConcreteProductA1 implements ProductA {
public void use() {
System.out.println("Using Product A1");
}
}
// 具体产品类A2
class ConcreteProductA2 implements ProductA {
public void use() {
System.out.println("Using Product A2");
}
}
// 具体产品类B1
class ConcreteProductB1 implements ProductB {
public void eat() {
System.out.println("Eating Product B1");
}
}
// 具体产品类B2
class ConcreteProductB2 implements ProductB {
public void eat() {
System.out.println("Eating Product B2");
}
}
// 抽象工厂接口
interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
// 具体工厂类1
class ConcreteFactory1 implements AbstractFactory {
public ProductA createProductA() {
return new ConcreteProductA1();
}
public ProductB createProductB() {
return new ConcreteProductB1();
}
}
// 具体工厂类2
class ConcreteFactory2 implements AbstractFactory {
public ProductA createProductA() {
return new ConcreteProductA2();
}
public ProductB createProductB() {
return new ConcreteProductB2();
}
}
// 客户端代码
public class AbstractFactoryPatternDemo {
public static void main(String[] args) {
AbstractFactory factory1 = new ConcreteFactory1();
ProductA productA1 = factory1.createProductA();
ProductB productB1 = factory1.createProductB();
productA1.use();
productB1.eat();
AbstractFactory factory2 = new ConcreteFactory2();
ProductA productA2 = factory2.createProductA();
ProductB productB2 = factory2.createProductB();
productA2.use();
productB2.eat();
}
}总结
工厂模式通过将对象的创建过程封装在工厂类中，使得代码更具扩展性和维护性。具体使用哪种工厂模式，取决于应用的复杂度和需求：
-
简单工厂模式：适用于简单的对象创建需求，结构简单但不具备扩展性。
-
工厂方法模式：适用于需要多个具体工厂来创建不同对象的情况，具备较好的扩展性。
-
抽象工厂模式：适用于需要创建一系列相关或相互依赖的对象的情况，提供了最高的灵活性和扩展性。