Java基础：简单工厂模式、工厂方法模式和抽象工厂模式综合概述

简单工厂模式、工厂方法模式和抽象工厂模式是面向对象设计中用来实现对象创建灵活性的三种不同形式的工厂模式。它们各自有其特点、适用场景及优缺点。以下是它们之间的区别以及对应的适用场景，以及示例说明：

简单工厂模式

定义：
简单工厂模式提供一个静态方法或非静态方法，通过接收参数来决定创建并返回何种具体产品对象。这个方法通常存在于一个单独的“工厂”类中，负责处理对象的创建细节。

特点：

• 集中控制对象的创建过程。
• 适用于创建逻辑相对简单、产品种类数量有限且易于扩展的情况。

适用场景：

• 创建对象的逻辑可能经常变化或者需要在运行时动态决定创建哪种对象。
• 产品之间存在一定的关联或继承关系，由同一个工厂进行管理。

示例：
假设有一个图形绘制应用程序，需要创建不同类型的图形（如圆形、矩形、三角形）。可以定义一个ShapeFactory来根据传入的类型字符串生成相应的Shape对象：

public interface Shape {
    void draw();
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}

public class Triangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a triangle");
    }
}

public class ShapeFactory {
    public static Shape createShape(String shapeType) {
        if ("circle".equals(shapeType)) {
            return new Circle();
        } else if ("rectangle".equals(shapeType)) {
            return new Rectangle();
        } else if ("triangle".equals(shapeType)) {
            return new Triangle();
        } else {
            throw new IllegalArgumentException("Invalid shape type");
        }
    }
}

// 使用
Shape circle = ShapeFactory.createShape("circle");
circle.draw();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

工厂方法模式

定义：
工厂方法模式定义了一个创建对象的接口，但让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。每个子类对应一种具体的产品，负责创建该产品的实例。

特点：

• 将具体产品的创建延迟到子类中完成，符合“开闭原则”，即对扩展开放，对修改关闭。
• 适用于产品族内的产品差异较大或产品种类繁多，且需要保持高度解耦。

适用场景：

• 当一个类不知道它所必须创建的对象的类时。
• 当一个类希望由它的子类来指定它所创建的对象的时候。
• 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

示例：
继续上述图形绘制应用程序的例子，如果产品种类增加且差异较大，可以采用工厂方法模式。首先定义一个抽象工厂接口和各种图形工厂子类：

public interface ShapeFactory {
    Shape createShape();
}

public class CircleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
}

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

public class TriangleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Triangle();
    }
}

// 使用
ShapeFactory circleFactory = new CircleFactory();
Shape circle = circleFactory.createShape();
circle.draw();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

抽象工厂模式

定义：
抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。客户端使用抽象工厂来创建对象族，而不直接使用具体产品类。

特点：

• 用于创建一族相关或相互依赖的对象（产品族），而不仅仅是一个产品对象。
• 提供一个高层接口，隐藏产品的具体实现系列，使得客户使用起来更加方便。

适用场景：

• 当一个系统不希望依赖于产品类实例如何被创建、组合和表达的细节时。
• 当一个系统需要独立于它的产品的创建、组合和表示时。
• 当一个系统的产品有多于一个的产品族，而系统只消费其中某一族的产品时。

示例：
假设图形应用程序除了形状之外，还引入了颜色概念，每种形状可以有不同的颜色（如红色圆形、蓝色圆形）。这时可以定义两个产品族：形状（Circle、Rectangle、Triangle）和颜色（Red、Blue）。抽象工厂模式可以创建这两类产品：

public interface Shape {
    void draw();
}

public class RedCircle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a red circle");
    }
}

public class BlueCircle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a blue circle");
    }

    // 其他形状和颜色的实现...

}

public interface ColorFactory {
    Color getColor();
}

public interface ShapeFactory {
    Shape getShape();
}

public class RedShapeFactory implements ColorFactory, ShapeFactory {
    @Override
    public Color getColor() {
        return new RedColor();
    }

    @Override
    public Shape getShape() {
        return new RedCircle();
    }
}

public class BlueShapeFactory implements ColorFactory, ShapeFactory {
    // 实现相应颜色和形状的创建...
}

// 使用
ShapeFactory redFactory = new RedShapeFactory();
Shape redCircle = redFactory.getShape();
redCircle.draw();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

总结来说，简单工厂模式适用于创建对象逻辑较简单且种类有限的情况；工厂方法模式适用于产品族内产品差异较大且需要保持高度解耦的场景；抽象工厂模式则适用于需要创建一族相关或相互依赖的对象（产品族）的情况。选择使用哪种模式取决于实际项目的需求和复杂度。