Java 设计模式之工厂模式

Java工厂模式是一种创建型设计模式，它提供了一个通用的接口来创建对象，使得对象的创建更加灵活和可维护。在Java中，通常有三种不同的工厂模式：简单工厂模式、工厂方法模式和抽象工厂模式。

1. 简单工厂模式
   简单工厂模式（Simple Factory Pattern）也称为静态工厂模式，通常由一个工厂类根据传入的参数决定创建哪一种产品类的实例。在Java中，常见的场景有：

• 根据不同的形状来创建不同的图形对象，如圆形、矩形、三角形等。
• 根据不同的支付方式来创建不同的支付对象，如微信支付、支付宝支付、银联支付等。

示例代码：

public interface Shape {
    void draw();
}

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

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

public class SimpleFactory {
    public static Shape getShape(String shapeType) {
        if ("CIRCLE".equalsIgnoreCase(shapeType)) {
            return new Circle();
        } else if ("RECTANGLE".equalsIgnoreCase(shapeType)) {
            return new Rectangle();
        } else {
            throw new IllegalArgumentException("Unsupported shape type: " + shapeType);
        }
    }
}

public class Client {
    public static void main(String[] args) {
        Shape circle = SimpleFactory.getShape("CIRCLE");
        Shape rectangle = SimpleFactory.getShape("RECTANGLE");
        circle.draw(); // 输出：Circle.draw()
        rectangle.draw(); // 输出：Rectangle.draw()
    }
}

2. 工厂方法模式
   工厂方法模式（Factory Method Pattern）定义了一个用于创建对象的接口，让子类决定实例化哪个类。在Java中，常见的场景有：

• 根据不同的日志类型来创建不同的日志记录器，如文件记录器、数据库记录器、控制台记录器等。
• 根据不同的图像类型来创建不同的图像读取器，如JPEG读取器、PNG读取器、GIF读取器等。

示例代码：

public interface Logger {
    void log(String message);
}

public class FileLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("File logger: " + message);
    }
}

public class DatabaseLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("Database logger: " + message);
    }
}

public interface LoggerFactory {
    Logger createLogger();
}

public class FileLoggerFactory implements LoggerFactory {
    @Override
    public Logger createLogger() {
        return new FileLogger();
    }
}

public class DatabaseLoggerFactory implements LoggerFactory {
    @Override
    public Logger createLogger() {
        return new DatabaseLogger();
    }
}

public class Client {
    public static void main(String[] args) {
        LoggerFactory factory = new FileLoggerFactory();
        Logger logger = factory.createLogger();
        logger.log("Hello World!"); // 输出：File logger: Hello World!
    }
}

3. 抽象工厂模式
   抽象工厂模式（Abstract Factory Pattern）提供了一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。在Java中，常见的场景有：

• 根据不同的主题风格来创建不同的UI组件对象，如按钮、文本框、标签等。
• 根据不同的数据库类型来创建不同的数据库连接对象、语句对象等。

示例代码：

public interface Button {
    void click();
}

public class LightButton implements Button {
    @Override
    public void click() {
        System.out.println("Light button clicked.");
    }
}

public class DarkButton implements Button {
    @Override
    public void click() {
        System.out.println("Dark button clicked.");
    }
}

public interface TextField {
    void input();
}

public class LightTextField implements TextField{
    @Override
    public void input() {
        System.out.println("Light text field input.");
    }
}

public class DarkTextField implements TextField {
    @Override
    public void input() {
        System.out.println("Dark text field input.");
    }
}

public interface UIComponentFactory {
    Button createButton();
    TextField createTextField();
}

public class LightUIComponentFactory implements UIComponentFactory {
    @Override
    public Button createButton() {
        return new LightButton();
    }

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

public class DarkUIComponentFactory implements UIComponentFactory {
    @Override
    public Button createButton() {
        return new DarkButton();
    }

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

public class Client {
    public static void main(String[] args) {
        UIComponentFactory factory = new LightUIComponentFactory();
        Button button = factory.createButton();
        TextField textField = factory.createTextField();
        button.click(); // 输出：Light button clicked.
        textField.input(); // 输出：Light text field input.
    }
}

在Java中，工厂模式被广泛应用于大量的框架和库中，如：

• JDK中的Calendar.getInstance()方法实际上是使用了简单工厂模式。
• Spring框架中的BeanFactory就是工厂方法模式的体现。
• MyBatis框架中的SqlSessionFactory是抽象工厂模式的体现。

以上就是Java工厂模式的详细介绍和常见运用场景，工厂模式在实际开发中应用广泛，能够有效提高代码的可维护性和可扩展性。