怡格网 | 详情

工厂模式的定义

在 Java 中，工厂模式是一种创建型设计模式，它提供了一种创建对象的方式，将对象的创建和使用分离。通过使用工厂模式，我们可以将对象的创建逻辑封装在一个工厂类中，使得代码更加灵活、可维护和可扩展。

工厂模式的类型及应用场景

1. 简单工厂模式

定义：简单工厂模式又称为静态工厂方法模式，它定义了一个工厂类，该类包含一个静态方法，根据传入的参数来决定创建并返回哪种具体产品的实例。
示例代码：

// 定义产品接口
interface Shape {
    void draw();
}

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

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

// 简单工厂类
class ShapeFactory {
    public static Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        }
        return null;
    }
}

// 客户端代码
public class SimpleFactoryExample {
    public static void main(String[] args) {
        Shape circle = ShapeFactory.getShape("CIRCLE");
        circle.draw();

        Shape rectangle = ShapeFactory.getShape("RECTANGLE");
        rectangle.draw();
    }
}

应用场景：
- 当创建对象的逻辑比较简单，且创建对象的种类较少时，可以使用简单工厂模式。例如，在一个小型的图形绘制程序中，根据用户输入的图形类型创建相应的图形对象。
- 当客户端只需要知道传入的参数，而不需要关心对象的创建过程时，简单工厂模式可以将对象的创建过程封装起来，提高代码的可维护性。

2. 工厂方法模式

定义：工厂方法模式定义了一个创建对象的抽象方法，让子类决定实例化哪个具体产品类。工厂方法模式将对象的创建延迟到子类中进行，使得工厂类和具体产品类之间的耦合度降低。
示例代码：

// 定义产品接口
interface Shape {
    void draw();
}

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

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

// 抽象工厂类
abstract class ShapeFactory {
    public abstract Shape createShape();
}

// 具体工厂类：圆形工厂
class CircleFactory extends ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
}

// 具体工厂类：矩形工厂
class RectangleFactory extends ShapeFactory {
    @Override
    public Shape createShape() {
        return new Rectangle();
    }
}

// 客户端代码
public class FactoryMethodExample {
    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();
    }
}

应用场景：
- 当一个类不知道它所需要的对象的具体类时，可以使用工厂方法模式。例如，在一个游戏开发中，不同的关卡可能需要不同类型的敌人，每个关卡可以作为一个具体的工厂类，负责创建该关卡所需的敌人对象。
- 当一个类希望由它的子类来指定创建对象的具体类时，工厂方法模式可以将对象的创建逻辑封装在子类中，使得代码更加灵活和可扩展。

3. 抽象工厂模式

定义：抽象工厂模式提供了一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂模式可以创建多个不同类型的产品，这些产品通常属于同一个产品族。
示例代码：

// 定义按钮接口
interface Button {
    void paint();
}

// 具体按钮类：Windows 按钮
class WindowsButton implements Button {
    @Override
    public void paint() {
        System.out.println("绘制 Windows 按钮");
    }
}

// 具体按钮类：Mac 按钮
class MacButton implements Button {
    @Override
    public void paint() {
        System.out.println("绘制 Mac 按钮");
    }
}

// 定义文本框接口
interface TextField {
    void render();
}

// 具体文本框类：Windows 文本框
class WindowsTextField implements TextField {
    @Override
    public void render() {
        System.out.println("绘制 Windows 文本框");
    }
}

// 具体文本框类：Mac 文本框
class MacTextField implements TextField {
    @Override
    public void render() {
        System.out.println("绘制 Mac 文本框");
    }
}

// 抽象工厂接口
interface GUIFactory {
    Button createButton();
    TextField createTextField();
}

// 具体工厂类：Windows 工厂
class WindowsFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new WindowsButton();
    }

    @Override
    public TextField createTextField() {
        return new WindowsTextField();
    }
}

// 具体工厂类：Mac 工厂
class MacFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new MacButton();
    }

    @Override
    public TextField createTextField() {
        return new MacTextField();
    }
}

// 客户端代码
public class AbstractFactoryExample {
    public static void main(String[] args) {
        GUIFactory windowsFactory = new WindowsFactory();
        Button windowsButton = windowsFactory.createButton();
        TextField windowsTextField = windowsFactory.createTextField();
        windowsButton.paint();
        windowsTextField.render();

        GUIFactory macFactory = new MacFactory();
        Button macButton = macFactory.createButton();
        TextField macTextField = macFactory.createTextField();
        macButton.paint();
        macTextField.render();
    }
}

应用场景：
- 当需要创建一组相关的产品对象，并且希望保证这些产品对象之间的兼容性时，可以使用抽象工厂模式。例如，在一个跨平台的图形用户界面（GUI）开发中，不同的操作系统（如 Windows、Mac）需要使用不同风格的按钮、文本框等组件，抽象工厂模式可以根据不同的操作系统创建相应的组件对象。
- 当系统需要独立于产品的创建、组合和表示时，抽象工厂模式可以将产品的创建逻辑封装在工厂类中，使得系统更加灵活和可维护。