工厂模式(Factory Pattern)是一种创建型设计模式,用于创建对象时不暴露对象创建的具体逻辑。它提供了一种将对象创建的职责交给工厂对象的方式,使得客户端代码与具体的类解耦。
工厂模式的主要类型:
-
简单工厂模式(Simple Factory Pattern):提供一个工厂类来创建对象,客户端只需要提供对象的参数,工厂类根据这些参数决定创建哪种具体的产品对象。
-
工厂方法模式(Factory Method Pattern):定义一个创建对象的接口,让子类决定实例化哪个类。工厂方法模式通过子类化来创建对象。
-
抽象工厂模式(Abstract Factory Pattern):提供一个创建一系列相关或相互依赖对象的接口,而无需指定具体类。它用于创建多个相关的对象,而不仅仅是单一对象。
1. 简单工厂模式
优点:
- 对客户端代码隐藏了具体的创建细节,简化了客户端代码。
- 可以集中管理对象创建的逻辑,易于维护。
缺点:
- 工厂类变得复杂,难以扩展和维护。
- 不符合开闭原则,如果需要新增产品,需要修改工厂类。
实现:
// 产品接口
public interface Product {
void use();
}
// 具体产品类1
public class ConcreteProductA implements Product {
@Override
public void use() {
System.out.println("Using Product A");
}
}
// 具体产品类2
public class ConcreteProductB implements Product {
@Override
public void use() {
System.out.println("Using Product B");
}
}
// 简单工厂类
public class SimpleFactory {
public static Product createProduct(String type) {
switch (type) {
case "A":
return new ConcreteProductA();
case "B":
return new ConcreteProductB();
default:
throw new IllegalArgumentException("Unknown product type");
}
}
}
2. 工厂方法模式
优点:
- 工厂方法模式符合开闭原则,增加新产品时,只需要新增具体工厂类,不需要修改现有工厂代码。
- 每个具体工厂类可以创建不同的产品,灵活性更高。
缺点:
- 增加了类的数量,系统复杂度提升。
- 需要定义一个工厂接口和多个具体工厂类。
实现:
// 产品接口
public interface Product {
void use();
}
// 具体产品类1
public class ConcreteProductA implements Product {
@Override
public void use() {
System.out.println("Using Product A");
}
}
// 具体产品类2
public class ConcreteProductB implements Product {
@Override
public void use() {
System.out.println("Using Product B");
}
}
// 工厂接口
public interface Factory {
Product createProduct();
}
// 具体工厂类1
public class ConcreteFactoryA implements Factory {
@Override
public Product createProduct() {
return new ConcreteProductA();
}
}
// 具体工厂类2
public class ConcreteFactoryB implements Factory {
@Override
public Product createProduct() {
return new ConcreteProductB();
}
}
3. 抽象工厂模式
优点:
- 可以创建多个相关或依赖的对象,提供一致的接口。
- 易于扩展,符合开闭原则。
缺点:
- 增加了系统的复杂性,需要创建多个工厂接口和具体工厂类。
- 如果产品族增加,工厂类和接口也需要增加。
实现:
// 抽象产品A
public interface ProductA {
void use();
}
// 抽象产品B
public interface ProductB {
void use();
}
// 具体产品A1
public class ConcreteProductA1 implements ProductA {
@Override
public void use() {
System.out.println("Using Product A1");
}
}
// 具体产品A2
public class ConcreteProductA2 implements ProductA {
@Override
public void use() {
System.out.println("Using Product A2");
}
}
// 具体产品B1
public class ConcreteProductB1 implements ProductB {
@Override
public void use() {
System.out.println("Using Product B1");
}
}
// 具体产品B2
public class ConcreteProductB2 implements ProductB {
@Override
public void use() {
System.out.println("Using Product B2");
}
}
// 抽象工厂
public interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
// 具体工厂1
public class ConcreteFactory1 implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA1();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB1();
}
}
// 具体工厂2
public class ConcreteFactory2 implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA2();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB2();
}
}
- 简单工厂模式适用于产品种类较少的情况,易于实现和管理,但灵活性较差。
- 工厂方法模式适用于产品种类较多的情况,每个工厂负责创建一种具体产品,符合开闭原则。
- 抽象工厂模式适用于需要创建多个相关对象的情况,可以在不同的产品族之间进行切换。