设计模式1-工厂模式

目录

1 简单工厂模式

2. 工厂方法模式

3. 抽象工厂模式

---

1 简单工厂模式

  简单工厂模式（Simple Factory Pattern）是一种创建型设计模式，它提供了一个简单的工厂类，根据不同的参数来实例化不同的对象，而客户端无需直接创建对象，只需要通过工厂类来获取所需的对象。以下是一个简单的 Java 示例，演示了如何使用简单工厂模式创建不同类型的汽车对象。   

   首先，定义一个抽象的汽车接口和具体的汽车实现类：

// 抽象汽车接口
interface Car {
    void drive();
}

// 具体汽车类：奥迪
class Audi implements Car {
    @Override
    public void drive() {
        System.out.println("Driving Audi");
    }
}

// 具体汽车类：宝马
class BMW implements Car {
    @Override
    public void drive() {
        System.out.println("Driving BMW");
    }
}

然后，创建一个简单工厂类 CarFactory，根据客户端传入的参数来实例化不同的汽车对象：

// 简单工厂类
class CarFactory {
    // 根据参数创建不同的汽车对象
    public static Car createCar(String carType) {
        if (carType.equalsIgnoreCase("Audi")) {
            return new Audi();
        } else if (carType.equalsIgnoreCase("BMW")) {
            return new BMW();
        } else {
            throw new IllegalArgumentException("Invalid car type: " + carType);
        }
    }
}

最后，编写客户端代码来使用简单工厂模式创建汽车对象：

public class Client {
    public static void main(String[] args) {
        // 使用简单工厂创建奥迪汽车
        Car audi = CarFactory.createCar("Audi");
        audi.drive();  // 输出: Driving Audi

        // 使用简单工厂创建宝马汽车
        Car bmw = CarFactory.createCar("BMW");
        bmw.drive();  // 输出: Driving BMW
    }
}

在上面的示例中，CarFactory 是一个简单工厂类，它根据客户端传入的参数（汽车类型）来创建不同的具体汽车对象（Audi 或 BMW）。客户端代码只需要调用工厂类的静态方法 createCar 并传入相应的参数，即可获取所需的汽车对象，而不需要直接实例化具体的汽车类。

简单工厂模式封装了对象的创建过程，使客户端代码与具体类的实现解耦，提高了代码的灵活性和可维护性。但需要注意的是，简单工厂模式违背了开闭原则，因为每次添加新的具体产品类都需要修改工厂类的代码。

2. 工厂方法模式

工厂方法模式（Factory Method Pattern）是一种创建型设计模式，它定义了一个用于创建对象的接口，但将对象的实际创建延迟到子类中。这样可以在不修改客户端代码的情况下，允许子类选择要实例化的对象类型。

下面是一个使用工厂方法模式的 Java 示例代码，演示了如何实现一个简单的图形绘制程序，其中使用了工厂方法来创建不同类型的图形对象。

首先，我们定义一个抽象图形类 Shape 和它的具体子类 Circle 和 Rectangle：

// 抽象图形类
public abstract class Shape {
    public abstract void draw();
}

// 具体图形类 - 圆形
public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Circle");
    }
}

// 具体图形类 - 矩形
public class Rectangle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Rectangle");
    }
}

接下来，定义一个抽象工厂类 ShapeFactory，它声明了一个抽象的工厂方法 createShape，由子类实现该方法来创建具体的图形对象。

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

然后，创建两个具体的工厂类，分别用于创建圆形和矩形对象：

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

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

最后，编写客户端代码来使用工厂方法创建图形对象：

public class Client {
    public static void main(String[] args) {
        // 使用圆形工厂创建圆形对象
        ShapeFactory circleFactory = new CircleFactory();
        Shape circle = circleFactory.createShape();
        circle.draw();  // 输出: Drawing Circle

        // 使用矩形工厂创建矩形对象
        ShapeFactory rectangleFactory = new RectangleFactory();
        Shape rectangle = rectangleFactory.createShape();
        rectangle.draw();  // 输出: Drawing Rectangle
    }
}

在这个示例中，ShapeFactory 是抽象工厂类，定义了一个抽象的工厂方法 createShape，它由具体的工厂类 CircleFactory 和 RectangleFactory 分别实现，用于创建 Circle 和 Rectangle 对象。客户端代码通过调用工厂方法 createShape 来创建具体的图形对象，而无需关心具体的对象创建细节。

工厂方法模式允许在不修改现有代码的情况下引入新的产品类和工厂类，增强了代码的灵活性和可扩展性。

3. 抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供一个接口，用于创建一系列相关或依赖对象的家族，而不需要明确指定具体类。这种模式属于工厂模式的一种扩展。

下面是一个抽象工厂模式的示例，演示了如何创建一个简单的 GUI（图形用户界面）工厂，用于创建不同操作系统下的按钮和窗口。

首先，定义抽象产品接口及其具体实现类：

// 抽象产品：按钮接口
interface Button {
    void click();
}

// 具体产品：Windows 按钮
class WindowsButton implements Button {
    @Override
    public void click() {
        System.out.println("Windows button clicked");
    }
}

// 具体产品：Mac 按钮
class MacButton implements Button {
    @Override
    public void click() {
        System.out.println("Mac button clicked");
    }
}

// 抽象产品：窗口接口
interface Window {
    void open();
}

// 具体产品：Windows 窗口
class WindowsWindow implements Window {
    @Override
    public void open() {
        System.out.println("Windows window opened");
    }
}

// 具体产品：Mac 窗口
class MacWindow implements Window {
    @Override
    public void open() {
        System.out.println("Mac window opened");
    }
}

然后，定义抽象工厂接口及其具体实现类：

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

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

    @Override
    public Window createWindow() {
        return new WindowsWindow();
    }
}

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

    @Override
    public Window createWindow() {
        return new MacWindow();
    }
}

最后，编写客户端代码来使用抽象工厂创建具体的 GUI 对象：

public class Client {
    private GUIFactory guiFactory;

    public Client(GUIFactory factory) {
        this.guiFactory = factory;
    }

    public void createUI() {
        Button button = guiFactory.createButton();
        Window window = guiFactory.createWindow();

        button.click();
        window.open();
    }

    public static void main(String[] args) {
        // 创建 Windows GUI
        Client windowsClient = new Client(new WindowsFactory());
        windowsClient.createUI();

        // 创建 Mac GUI
        Client macClient = new Client(new MacFactory());
        macClient.createUI();
    }
}

在上面的示例中，抽象工厂模式通过 GUIFactory 接口定义了创建按钮和窗口的方法。WindowsFactory 和 MacFactory 分别是具体工厂类，负责创建 Windows 系统和 Mac 系统下的按钮和窗口对象。客户端根据需要选择合适的工厂类，并通过工厂类创建按钮和窗口，而无需关心具体产品的实现细节。

抽象工厂模式有助于确保产品系列之间的兼容性，因为同一工厂生产的产品通常可以相互配合使用。此外，抽象工厂模式也支持添加新的产品系列，而不影响现有客户端代码，具有良好的扩展性和灵活性。