Java工厂模式实战：深入解析与案例分析
一、工厂模式概述
工厂模式（Factory Pattern）是面向对象设计模式中的一种，它提供了一种创建对象的最佳实践。工厂模式的主要目的是将对象的创建与对象的使用分离，从而降低系统的耦合度，提高代码的可维护性和可扩展性。在Java中，工厂模式主要分为三种：简单工厂模式、工厂方法模式和抽象工厂模式。
二、简单工厂模式实战
简单工厂模式是最基础的工厂模式，它由一个工厂类负责创建所有类型的对象。以下是一个简单的工厂模式示例：
```java
// 抽象产品类
class Product {
public void method() {
System.out.println("Product method");
}
}
// 具体产品类
class ConcreteProduct1 extends Product {
@Override
public void method() {
System.out.println("ConcreteProduct1 method");
}
}
class ConcreteProduct2 extends Product {
@Override
public void method() {
System.out.println("ConcreteProduct2 method");
}
}
// 简单工厂类
class SimpleFactory {
public static Product createProduct(String type) {
if ("1".equals(type)) {
return new ConcreteProduct1();
} else if ("2".equals(type)) {
return new ConcreteProduct2();
}
return null;
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
Product product1 = SimpleFactory.createProduct("1");
product1.method();
Product product2 = SimpleFactory.createProduct("2");
product2.method();
}
}
```
在这个例子中，我们定义了一个抽象产品类`Product`和两个具体产品类`ConcreteProduct1`和`ConcreteProduct2`。`SimpleFactory`类负责根据传入的参数创建相应的产品对象。客户端代码通过调用`SimpleFactory.createProduct()`方法获取产品对象，并调用其方法。
三、工厂方法模式实战
工厂方法模式是对简单工厂模式的改进，它将工厂类的职责分解为两个部分：创建对象的职责和具体工厂类的职责。以下是一个工厂方法模式的示例：
```java
// 抽象产品类
class Product {
public void method() {
System.out.println("Product method");
}
}
// 具体产品类
class ConcreteProduct1 extends Product {
@Override
public void method() {
System.out.println("ConcreteProduct1 method");
}
}
class ConcreteProduct2 extends Product {
@Override
public void method() {
System.out.println("ConcreteProduct2 method");
}
}
// 抽象工厂类
interface Factory {
Product createProduct();
}
// 具体工厂类
class ConcreteFactory1 implements Factory {
@Override
public Product createProduct() {
return new ConcreteProduct1();
}
}
class ConcreteFactory2 implements Factory {
@Override
public Product createProduct() {
return new ConcreteProduct2();
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
Factory factory1 = new ConcreteFactory1();
Product product1 = factory1.createProduct();
product1.method();
Factory factory2 = new ConcreteFactory2();
Product product2 = factory2.createProduct();
product2.method();
}
}
```
在这个例子中，我们定义了一个抽象工厂类`Factory`和两个具体工厂类`ConcreteFactory1`和`ConcreteFactory2`。客户端代码通过传入具体工厂类的实例来获取产品对象。
四、抽象工厂模式实战
抽象工厂模式是对工厂方法模式的进一步抽象，它允许创建相关或依赖对象的家族。以下是一个抽象工厂模式的示例：
```java
// 抽象产品类
interface ProductA {
void methodA();
}
interface ProductB {
void methodB();
}
// 具体产品类
class ConcreteProductA1 implements ProductA {
@Override
public void methodA() {
System.out.println("ConcreteProductA1 methodA");
}
}
class ConcreteProductA2 implements ProductA {
@Override
public void methodA() {
System.out.println("ConcreteProductA2 methodA");
}
}
class ConcreteProductB1 implements ProductB {
@Override
public void methodB() {
System.out.println("ConcreteProductB1 methodB");
}
}
class ConcreteProductB2 implements ProductB {
@Override
public void methodB() {
System.out.println("ConcreteProductB2 methodB");
}
}
// 抽象工厂类
interface FactoryA {
ProductA createProductA();
}
interface FactoryB {
ProductB createProductB();
}
// 具体工厂类
class ConcreteFactoryA implements FactoryA {
@Override
public ProductA createProductA() {
return new ConcreteProductA1();
}
}
class ConcreteFactoryB implements FactoryB {
@Override
public ProductB createProductB() {
return new ConcreteProductB1();
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
FactoryA factoryA = new ConcreteFactoryA();
ProductA productA = factoryA.createProductA();
productA.methodA();
FactoryB factoryB = new ConcreteFactoryB();
ProductB productB = factoryB.createProductB();
productB.methodB();
}
}
```
在这个例子中，我们定义了两个抽象产品类`ProductA`和`ProductB`，以及两个具体产品类`ConcreteProductA1`、`ConcreteProductA2`、`ConcreteProductB1`和`ConcreteProductB2`。`FactoryA`和`FactoryB`是两个抽象工厂类，分别负责创建`ProductA`和`ProductB`。客户端代码通过传入具体工厂类的实例来获取产品对象。
五、总结
本文深入分析了Java工厂模式的三种类型：简单工厂模式、工厂方法模式和抽象工厂模式，并通过实际案例展示了如何在Java项目中应用工厂模式。工厂模式在降低系统耦合度、提高代码可维护性和可扩展性方面具有重要作用，是Java开发者必备的技能之一。
