java三个工厂设计模式

Java 中的三个工厂设计模式分别是：简单工厂模式、工厂方法模式、抽象工厂模式。它们的核心都是封装对象创建过程，让客户端与具体产品类解耦，但复杂度和适用场景逐步提升。

一、简单工厂模式（Simple Factory Pattern）

核心：由一个工厂类根据传入参数，决定创建哪一种产品实例。
角色：
1. 产品接口：定义产品的公共方法。
2. 具体产品类：实现产品接口，是工厂创建的目标对象。
3. 工厂类：包含静态方法，根据参数返回具体产品实例。
优点：客户端无需知道产品创建细节，只需传入参数即可获取对象。
缺点：工厂类职责过重，新增产品需修改工厂类代码，违反开闭原则。
适用场景：产品类型少、不频繁新增的简单场景。

// 1. 产品接口
interface Shape {
void draw();
}

// 2. 具体产品类
class Circle implements Shape {
@Override
public void draw() {
System.out.println("绘制圆形");
}
}

class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("绘制矩形");
}
}

// 3. 工厂类
class ShapeFactory {
// 静态工厂方法
public static Shape createShape(String type) {
if ("circle".equalsIgnoreCase(type)) {
return new Circle();
} else if ("rectangle".equalsIgnoreCase(type)) {
return new Rectangle();
}
return null;
}
}

// 客户端调用
public class SimpleFactoryDemo {
public static void main(String[] args) {
Shape circle = ShapeFactory.createShape("circle");
circle.draw(); // 输出：绘制圆形
复制代码
```
      Shape rectangle = ShapeFactory.createShape("rectangle");
      rectangle.draw(); // 输出：绘制矩形
  }
```
}

二、工厂方法模式（Factory Method Pattern）

核心：定义工厂接口 ，将产品创建延迟到具体工厂子类实现，一个产品对应一个工厂。
角色：
1. 产品接口：同简单工厂。
2. 具体产品类：同简单工厂。
3. 工厂接口：定义创建产品的抽象方法。
4. 具体工厂类：实现工厂接口，负责创建对应具体产品。
优点：符合开闭原则，新增产品只需新增具体产品和对应工厂，无需修改原有代码。
缺点：类的数量随产品增加而增多，系统复杂度上升。
适用场景：产品类型多、需频繁新增产品的场景。

// 1. 产品接口
interface Shape {
void draw();
}

// 2. 具体产品类
class Circle implements Shape {
@Override
public void draw() {
System.out.println("绘制圆形");
}
}

class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("绘制矩形");
}
}

// 3. 工厂接口
interface ShapeFactory {
Shape createShape();
}

// 4. 具体工厂类
class CircleFactory implements ShapeFactory {
@Override
public Shape createShape() {
return new Circle();
}
}

class RectangleFactory implements ShapeFactory {
@Override
public Shape createShape() {
return new Rectangle();
}
}

// 客户端调用
public class FactoryMethodDemo {
public static void main(String[] args) {
ShapeFactory circleFactory = new CircleFactory();
Shape circle = circleFactory.createShape();
circle.draw(); // 输出：绘制圆形
复制代码
```
      ShapeFactory rectangleFactory = new RectangleFactory();
      Shape rectangle = rectangleFactory.createShape();
      rectangle.draw(); // 输出：绘制矩形
  }
```
}

三、抽象工厂模式（Abstract Factory Pattern）

核心：提供接口创建一系列相关 / 依赖的产品对象（产品族），一个工厂可创建多个不同类型的产品。
角色：
1. 抽象产品接口：多个（如 Button、Text），定义不同产品的公共方法。
2. 具体产品类：实现抽象产品接口，属于不同产品族（如 WindowsButton、MacButton）。
3. 抽象工厂接口：定义创建所有产品的方法。
4. 具体工厂类：实现抽象工厂接口，创建同一产品族的所有产品。
优点：保证产品族内产品兼容性，新增产品族符合开闭原则。
缺点：新增产品等级结构（如新增 Checkbox）时，需修改所有工厂类，违反开闭原则。
适用场景：需创建多个产品族、且产品族内产品存在依赖关系的场景（如不同操作系统的 UI 组件）

// 1. 抽象产品接口（产品等级1：按钮）
interface Button {
void click();
}

// 抽象产品接口（产品等级2：文本框）
interface Text {
void input();
}

// 2. 具体产品类（Windows 产品族）
class WindowsButton implements Button {
@Override
public void click() {
System.out.println("Windows 按钮被点击");
}
}

class WindowsText implements Text {
@Override
public void input() {
System.out.println("Windows 文本框输入");
}
}

// 具体产品类（Mac 产品族）
class MacButton implements Button {
@Override
public void click() {
System.out.println("Mac 按钮被点击");
}
}

class MacText implements Text {
@Override
public void input() {
System.out.println("Mac 文本框输入");
}
}

// 3. 抽象工厂接口
interface UIFactory {
Button createButton();
Text createText();
}

// 4. 具体工厂类（Windows 工厂）
class WindowsFactory implements UIFactory {
@Override
public Button createButton() {
return new WindowsButton();
}
复制代码
```
  @Override
  public Text createText() {
      return new WindowsText();
  }
```
}

// 具体工厂类（Mac 工厂）
class MacFactory implements UIFactory {
@Override
public Button createButton() {
return new MacButton();
}
复制代码
```
  @Override
  public Text createText() {
      return new MacText();
  }
```
}

// 客户端调用
public class AbstractFactoryDemo {
public static void main(String[] args) {
// 创建 Windows 产品族
UIFactory windowsFactory = new WindowsFactory();
Button windowsButton = windowsFactory.createButton();
Text windowsText = windowsFactory.createText();
windowsButton.click(); // 输出：Windows 按钮被点击
windowsText.input(); // 输出：Windows 文本框输入
复制代码
```
      // 创建 Mac 产品族
      UIFactory macFactory = new MacFactory();
      Button macButton = macFactory.createButton();
      Text macText = macFactory.createText();
      macButton.click(); // 输出：Mac 按钮被点击
      macText.input(); // 输出：Mac 文本框输入
  }
```
}

|------------|-------------|-------------|-------------|------------------|
| 模式 | 核心特点 | 工厂数量 | 产品创建方式 | 开闭原则 |
| 简单工厂模式 | 单一工厂创建所有产品 | 1 个 | 静态方法 + 参数判断 | 违反 |
| 工厂方法模式 | 一个工厂对应一个产品 | 多个（与产品数一致） | 子类工厂实现创建 | 符合 |
| 抽象工厂模式 | 一个工厂创建一个产品族 | 多个（与产品族数一致） | 工厂创建多个相关产品 | 新增产品族符合，新增产品等级违反 |

总结

简单工厂：基础模式，适合简单场景，缺点是违反开闭原则。
工厂方法：解决了简单工厂的开闭原则问题，适合单一产品类型扩展。
抽象工厂：工厂模式的最高级形态，适合多产品族、多产品类型的复杂场景。