抽象工厂模式

java/ 设计模式基础设计模式

创建时间:2024-08-13 17:33

0x00 抽象工厂模式

0x00 抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一种接口，可以创建一系列相关或相互依赖的对象，而无需指定它们具体的类。与工厂模式不同的是，抽象工厂模式关注的是一个产品系列中的多个相关产品，并且这些产品通常需要一起工作。

抽象工厂模式的基本结构包括以下几个部分：

抽象产品（Product）: 定义了产品的接口，它是所有具体产品的公共父类或接口。
具体产品（Concrete Product）: 实现了抽象产品接口的具体类。
抽象工厂（Creator）: 定义了创建一系列相关或相互依赖的对象的接口。
具体工厂（Concrete Creator）: 实现了抽象工厂接口，包含具体的产品实现逻辑。

示例需求

假设我们有一个图形绘制应用，我们需要创建不同类型的图形，如圆形（Circle）、矩形（Rectangle）等，并且每种图形有不同的风格（例如：实线风格、虚线风格）。

类图

classDiagram
class Shape {
    +draw()
}
class Color {
    +fill()
}


class Circle {
    -Color color
    +draw()
    +fill()
}

class Rectangle {
    -Color color
    +draw()
    +fill()
}

class RedColor {
    +fill()
}

class BlueColor {
    +fill()
}

class AbstractFactory {
    +getShape(): Shape
    +getColor(): Color
}

class RoundedRectangleFactory {
    +getShape(): Shape
    +getColor(): Color
}

ClientApp..|>Shape
ClientApp..|>Color
ClientApp..|>AbstractFactory
Shape <|-- Circle
Shape <|-- Rectangle
Color <|-- BlueColor
Color <|-- RedColor

AbstractFactory <|-- RoundedRectangleFactory
Circle<|..RoundedRectangleFactory
Rectangle<|..RoundedRectangleFactory
BlueColor<|..RoundedRectangleFactory
RedColor<|..RoundedRectangleFactory

Shape<|..AbstractFactory
Color<|..AbstractFactory

代码

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

public interface Color {
    void fill();
}

// 创建具体产品
public class RedColor implements Color {
    @Override
    public void fill() {
        System.out.println("Filling red color.");
    }
}

public class BlueColor implements Color {
    @Override
    public void fill() {
        System.out.println("Filling blue color.");
    }
}

public class Circle implements Shape {
    private Color color;

    public Circle(Color color) {
        this.color = color;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a circle.");
        color.fill();
    }
}

public class Rectangle implements Shape {
    private Color color;

    public Rectangle(Color color) {
        this.color = color;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a rectangle.");
        color.fill();
    }
}

// 定义抽象工厂
public interface AbstractFactory {
    Shape getShape(String shapeType);
    Color getColor(String colorType);
}

// 定义具体工厂

public class RoundedRectangleFactory implements AbstractFactory {
    @Override
    public Shape getShape(String shapeType) {
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle(new RedColor());
        } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle(new BlueColor());
        }
        return null;
    }

    @Override
    public Color getColor(String colorType) {
        // This is just for demonstration and can be implemented as needed.
        return null;
    }
}


// 使用抽象工厂
public class ClientApp {
    public static void main(String[] args) {
        AbstractFactory factory = new RoundedRectangleFactory();
        
        Shape shape1 = factory.getShape("CIRCLE");
        shape1.draw();
        
        Shape shape2 = factory.getShape("RECTANGLE");
        shape2.draw();
    }
}

抽象工厂模式和工厂模式的区别

它们解决的问题和应用场景有所不同。

工厂模式
工厂模式定义了一个用于创建对象的接口，但允许子类决定实例化哪一个类。工厂方法让一个类的实例化延迟到其子类。

特点：

提供了一个创建对象的接口。
子类可以重写这个接口来改变所创建的对象类型。
主要用于创建同一类族的单个对象。
优点：
遵循开闭原则（Open/Closed Principle），易于扩展新类。
将创建逻辑封装起来，客户端不必知道具体类的构造细节。
缺点：
每新增一个产品都需要添加一个对应的工厂类。

抽象工厂模式
抽象工厂模式提供了一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们具体的类。

特点：

提供一个接口，用于创建一系列相关的对象。
不需要指定每个对象的具体类。
主要用于创建同一产品族中的多个对象。
优点：
可以创建一系列相关的产品。
更容易交换产品家族。
遵循开闭原则。
缺点：
如果产品族中的一个产品发生变化，可能会影响整个产品族。
产品族必须严格匹配，这限制了灵活性。
区别
创建对象的数量:
工厂模式：只负责创建一个对象，即一个产品族中的单一产品。
抽象工厂模式：负责创建一系列相关对象，即一个完整的产品族。
适用场景:
工厂模式：适用于创建一个产品族中的一个产品，比如创建不同的图形对象（圆形、矩形等）。
抽象工厂模式：适用于创建一个产品族中的多个相关产品，比如创建不同风格的图形对象（比如 Windows 风格和 Mac 风格的按钮和文本框）。
代码结构:
工厂模式：通常涉及一个抽象工厂类和一个或多个具体工厂类。
抽象工厂模式：通常涉及一个抽象工厂类和一个或多个具体工厂类，以及多个抽象产品类和具体产品类