java开辟中的计划模式之工厂模式

发表于 2025-9-23 05:47:00

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要登录才可以下载或查看，没有账号？立即注册

×

工厂模式在Java开辟中的详细讲授

工厂模式（Factory Pattern）是Java中最常用的计划模式之一，它提供了一种创建对象的最佳方式。在工厂模式中，对象的创建逻辑对客户端是隐藏的，客户端通过一个共同的接口来利用新创建的对象，从而实现解耦和灵活性。本文将详细讲授工厂模式的范例、利用场景，并联合代码示例进行说明。
工厂模式主要分为三种范例：

简单工厂模式（Simple Factory Pattern）
工厂方法模式（Factory Method Pattern）
抽象工厂模式（Abstract Factory Pattern）

下面将逐一先容每种范例，包罗界说、利用场景、代码示例及其优缺点。

1. 简单工厂模式

界说

简单工厂模式（也称为静态工厂方法模式）通过界说一个工厂类，根据客户端传入的参数来创建差异的对象实例。工厂类封装了对象的创建逻辑，客户端只需提供参数即可得到对象。
利用场景

简单工厂模式实用于以了局景：

必要根据差异参数创建差异对象，且产物种类较少且不易变革。
比方，根据设置文件选择创建差异的数据库毗连（如MySQL、PostgreSQL）。

代码示例

以下是一个简单工厂模式的实现，模仿创建差异范例的“产物”：

// 产品接口
public interface Product {
void use();
}
// 具体产品A
public class ConcreteProductA implements Product {
@Override
public void use() {
System.out.println("使用产品A");
}
}
// 具体产品B
public class ConcreteProductB implements Product {
@Override
public void use() {
System.out.println("使用产品B");
}
}
// 工厂类
public class SimpleFactory {
public static Product createProduct(String type) {
if ("A".equals(type)) {
return new ConcreteProductA();
} else if ("B".equals(type)) {
return new ConcreteProductB();
}
return null;
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
Product productA = SimpleFactory.createProduct("A");
productA.use(); // 输出: 使用产品A
Product productB = SimpleFactory.createProduct("B");
productB.use(); // 输出: 使用产品B
}
}

复制代码

优点

简单易用：客户端无需知道详细产物类的实现，只需传递参数即可。
集中管理：对象的创建逻辑集中在工厂类中，便于维护。

缺点

扩展性差：每增长一个新产物，都必要修改工厂类的代码，违反了“开闭原则”（对扩睁开放，对修改关闭）。

2. 工厂方法模式

界说

工厂方法模式界说了一个创建对象的接口（工厂接口），但将详细的对象实例化推迟到子类中实现。每个详细产物由对应的详细工厂类负责创建。
利用场景

工厂方法模式实用于以了局景：

一个类无法提前知道必要创建的详细对象范例。
必要通过子类来指定创建的对象。
比方，差异范例的日志记录器（如文件日志、网络日志）的创建。

代码示例

以下是一个工厂方法模式的实现，创建差异范例的产物：

// 产品接口
public interface Product {
void use();
}
// 具体产品A
public class ConcreteProductA implements Product {
@Override
public void use() {
System.out.println("使用产品A");
}
}
// 具体产品B
public class ConcreteProductB implements Product {
@Override
public void use() {
System.out.println("使用产品B");
}
}
// 工厂接口
public interface Factory {
Product createProduct();
}
// 具体工厂A
public class ConcreteFactoryA implements Factory {
@Override
public Product createProduct() {
return new ConcreteProductA();
}
}
// 具体工厂B
public class ConcreteFactoryB implements Factory {
@Override
public Product createProduct() {
return new ConcreteProductB();
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
Factory factoryA = new ConcreteFactoryA();
Product productA = factoryA.createProduct();
productA.use(); // 输出: 使用产品A
Factory factoryB = new ConcreteFactoryB();
Product productB = factoryB.createProduct();
productB.use(); // 输出: 使用产品B
}
}

复制代码

优点

符合开闭原则：增长新产物时，只需新增详细工厂和产物类，无需修改现有代码。
解耦：客户端与详细产物类解耦，只依靠工厂接口。

缺点

类数目增长：每增长一个新产物，都必要新增一个详细工厂类，导致类数目变多。

3. 抽象工厂模式

界说

抽象工厂模式提供了一个接口，用于创建一系列相干或相互依靠的对象，而无需指定它们的详细类。它通常用于创建一组产物族。
利用场景

抽象工厂模式实用于以了局景：

必要创建一组相干或相互依靠的对象，且这些对象之间有肯定的束缚关系。
比方，创建差异风格的UI组件（如Windows风格、Mac风格的按钮和文本框）。

代码示例

以下是一个抽象工厂模式的实现，创建两组相干的产物：

// 抽象产品A
public interface AbstractProductA {
void use();
}
// 具体产品A1
public class ConcreteProductA1 implements AbstractProductA {
@Override
public void use() {
System.out.println("使用产品A1");
}
}
// 具体产品A2
public class ConcreteProductA2 implements AbstractProductA {
@Override
public void use() {
System.out.println("使用产品A2");
}
}
// 抽象产品B
public interface AbstractProductB {
void use();
}
// 具体产品B1
public class ConcreteProductB1 implements AbstractProductB {
@Override
public void use() {
System.out.println("使用产品B1");
}
}
// 具体产品B2
public class ConcreteProductB2 implements AbstractProductB {
@Override
public void use() {
System.out.println("使用产品B2");
}
}
// 抽象工厂接口
public interface AbstractFactory {
AbstractProductA createProductA();
AbstractProductB createProductB();
}
// 具体工厂1
public class ConcreteFactory1 implements AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ConcreteProductA1();
}
@Override
public AbstractProductB createProductB() {
return new ConcreteProductB1();
}
}
// 具体工厂2
public class ConcreteFactory2 implements AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ConcreteProductA2();
}
@Override
public AbstractProductB createProductB() {
return new ConcreteProductB2();
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
AbstractFactory factory1 = new ConcreteFactory1();
AbstractProductA productA1 = factory1.createProductA();
AbstractProductB productB1 = factory1.createProductB();
productA1.use(); // 输出: 使用产品A1
productB1.use(); // 输出: 使用产品B1
AbstractFactory factory2 = new ConcreteFactory2();
AbstractProductA productA2 = factory2.createProductA();
AbstractProductB productB2 = factory2.createProductB();
productA2.use(); // 输出: 使用产品A2
productB2.use(); // 输出: 使用产品B2
}
}

复制代码

优点

产物族同等性：确保由同一工厂创建的产物是兼容的。
解耦：客户端与详细产物类解耦，只依靠抽象工厂接口。

缺点

扩展性有限：假如必要增长新的产物范例（如新增AbstractProductC），必要修改抽象工厂接口和全部详细工厂类，违反开闭原则。

总结与选择指南

三种工厂模式的对比

模式实用场景优点缺点简单工厂模式产物种类少且固定简单易用，逻辑集中扩展性差，违反开闭原则工厂方法模式产物种类多，需灵活扩展符合开闭原则，解耦类数目增长抽象工厂模式创建一组相干或依靠的对象包管产物族同等性，解耦扩展新产物范例困难如何选择

简单工厂模式：适合小型项目或产物种类较少、不常变革的场景。
工厂方法模式：适合必要动态扩展产物范例的场景，如框架开辟。
抽象工厂模式：适合必要创建一组相干对象的复杂系统，如跨平台的UI组件库。

通过合理选择工厂模式，可以提高Java代码的可维护性、扩展性息争耦性。在实际开辟中，发起根据详细需求衡量每种模式的优缺点，以计划出优雅的系统架构。

java开辟中的计划模式之工厂模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

浏览过的版块

南飓风