在前一篇中，我们深入探讨了单例模式，它保证了类只有一个实例，并提供了一个全局访问点。今天，我们将继续探索工厂模式，这是一种创建对象的设计模式，用于将对象的实例化推迟到子类。

工厂模式简介

工厂模式主要旨在通过定义一个接口或抽象类，让客户端无需了解具体的实现类，便可以通过工厂方法创建对象。这样做的好处在于低耦合性，使得代码更加灵活和可维护。在Java中，工厂模式通常分为两种类型：简单工厂模式和抽象工厂模式。

简单工厂模式

简单工厂模式通过一个工厂类，根据传入参数返回不同类的实例。在这种模式中，工厂类负责创建对象，并将创建对象的逻辑与使用对象的逻辑分离。

示例案例

假设我们要创建一个图形绘制应用，根据不同类型绘制不同的图形（例如：圆形和方形）。我们可以创建一个简单工厂来实现这一功能。

// 图形接口
public interface Shape {
    void draw();
}

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

// 方形类
public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Square");
    }
}

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

// 客户端代码
public class FactoryPatternDemo {
    public static void main(String[] args) {
        Shape shape1 = ShapeFactory.getShape("CIRCLE");
        shape1.draw(); // 输出：Drawing a Circle

        Shape shape2 = ShapeFactory.getShape("SQUARE");
        shape2.draw(); // 输出：Drawing a Square
    }
}
复制

在上述示例中，ShapeFactory负责根据提供的形状类型返回相应的形状对象。客户端通过调用工厂方法，而无需关心具体实现。

抽象工厂模式

与简单工厂模式不同，抽象工厂模式提供一个接口，允许创建一组相关或相互依赖的对象。这样，客户可以使用工厂接口来创建对象，而不必了解具体的实现类。

示例案例

继续之前的图形绘制应用，我们引入颜色的概念，使得我们可以为每种图形选择颜色。这里我们将创建一个抽象工厂。

// 颜色接口
public interface Color {
    void fill();
}

// 红色类
public class Red implements Color {
    @Override
    public void fill() {
        System.out.println("Filling with Red Color");
    }
}

// 绿色类
public class Green implements Color {
    @Override
    public void fill() {
        System.out.println("Filling with Green Color");
    }
}

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

// 形状工厂类
public class ShapeFactory implements AbstractFactory {
    @Override
    public Shape getShape(String shapeType) {
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("SQUARE")) {
            return new Square();
        }
        return null;
    }

    @Override
    public Color getColor(String colorType) {
        return null; // 不处理颜色
    }
}

// 颜色工厂类
public class ColorFactory implements AbstractFactory {
    @Override
    public Shape getShape(String shapeType) {
        return null; // 不处理形状
    }

    @Override
    public Color getColor(String colorType) {
        if (colorType.equalsIgnoreCase("RED")) {
            return new Red();
        } else if (colorType.equalsIgnoreCase("GREEN")) {
            return new Green();
        }
        return null;
    }
}

// 工厂生成器
public class FactoryProducer {
    public static AbstractFactory getFactory(boolean isShapeFactory) {
        if (isShapeFactory) {
            return new ShapeFactory();
        } else {
            return new ColorFactory();
        }
    }
}

// 客户端代码
public class AbstractFactoryPatternDemo {
    public static void main(String[] args) {
        AbstractFactory shapeFactory = FactoryProducer.getFactory(true);
        Shape shape1 = shapeFactory.getShape("CIRCLE");
        shape1.draw();
        
        AbstractFactory colorFactory = FactoryProducer.getFactory(false);
        Color color1 = colorFactory.getColor("RED");
        color1.fill();
    }
}
复制

在这个示例中，我们定义了一个AbstractFactory接口，分别实现于ShapeFactory和ColorFactory。客户端根据需要可以使用FactoryProducer获取不同的工厂，进而创建相应的对象。

总结

工厂模式是一种创建对象的设计模式，有助于降低耦合度并增强系统的灵活性。通过使用工厂模式，无论是简单工厂还是抽象工厂，我们都能够将对象的创建与使用分离，从而遵循单一职责原则和开闭原则。在下一篇文章中，我们将继续探讨观察者模式，深入理解如何实现对象之间的解耦合与事件驱动的设计理念。