Java工厂方法模式：创建对象的优雅之道

简介

在Java开发中，对象的创建过程往往会变得复杂且难以维护。工厂方法模式（Factory Method Pattern）作为一种创建型设计模式，提供了一种创建对象的方式，将对象的创建和使用分离，使得代码更加灵活、可维护和可扩展。本文将深入探讨Java工厂方法模式的基础概念、使用方法、常见实践以及最佳实践。

基础概念

工厂方法模式定义了一个创建对象的接口，让子类决定实例化哪个类。工厂方法把对象的创建逻辑封装在一个工厂类中，而不是在客户端代码中直接实例化对象。这种模式包含以下几个角色： - 抽象产品（Product）：定义了产品的接口或抽象类，描述了产品的通用特性和行为。 - 具体产品（Concrete Product）：实现了抽象产品接口或继承自抽象产品类，代表具体的产品对象。 - 抽象工厂（Creator）：声明了工厂方法，该方法返回一个抽象产品类型的对象。这个方法是创建对象的接口。 - 具体工厂（Concrete Creator）：实现了抽象工厂的工厂方法，负责创建具体的产品对象。

使用方法

简单工厂模式（非标准模式）

简单工厂模式是工厂方法模式的简化版本，它定义了一个工厂类，负责创建产品对象。虽然它不是一个正式的设计模式，但在实际开发中经常被使用。

// 抽象产品
abstract class Product {
    public abstract void operation();
}

// 具体产品
class ConcreteProduct extends Product {
    @Override
    public void operation() {
        System.out.println("执行具体产品的操作");
    }
}

// 简单工厂类
class SimpleFactory {
    public static Product createProduct() {
        return new ConcreteProduct();
    }
}

// 客户端代码
public class SimpleFactoryClient {
    public static void main(String[] args) {
        Product product = SimpleFactory.createProduct();
        product.operation();
    }
}

工厂方法模式

工厂方法模式将简单工厂模式中的工厂方法抽象到抽象工厂类中，由具体工厂类实现。

// 抽象产品
abstract class Product {
    public abstract void operation();
}

// 具体产品1
class ConcreteProduct1 extends Product {
    @Override
    public void operation() {
        System.out.println("执行具体产品1的操作");
    }
}

// 具体产品2
class ConcreteProduct2 extends Product {
    @Override
    public void operation() {
        System.out.println("执行具体产品2的操作");
    }
}

// 抽象工厂
abstract class Creator {
    public abstract Product createProduct();
}

// 具体工厂1
class ConcreteCreator1 extends Creator {
    @Override
    public Product createProduct() {
        return new ConcreteProduct1();
    }
}

// 具体工厂2
class ConcreteCreator2 extends Creator {
    @Override
    public Product createProduct() {
        return new ConcreteProduct2();
    }
}

// 客户端代码
public class FactoryMethodClient {
    public static void main(String[] args) {
        Creator creator1 = new ConcreteCreator1();
        Product product1 = creator1.createProduct();
        product1.operation();

        Creator creator2 = new ConcreteCreator2();
        Product product2 = creator2.createProduct();
        product2.operation();
    }
}

常见实践

结合多态实现对象创建

在实际应用中，我们可以根据不同的条件选择不同的具体工厂来创建产品对象，实现多态性。

// 抽象产品
abstract class Shape {
    public abstract void draw();
}

// 具体产品：圆形
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

// 具体产品：矩形
class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}

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

// 具体工厂：圆形工厂
class CircleFactory extends ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
}

// 具体工厂：矩形工厂
class RectangleFactory extends ShapeFactory {
    @Override
    public Shape createShape() {
        return new Rectangle();
    }
}

// 客户端代码
public class ShapeClient {
    public static void main(String[] args) {
        ShapeFactory circleFactory = new CircleFactory();
        Shape circle = circleFactory.createShape();
        circle.draw();

        ShapeFactory rectangleFactory = new RectangleFactory();
        Shape rectangle = rectangleFactory.createShape();
        rectangle.draw();
    }
}

处理复杂对象创建

当产品对象的创建过程复杂，涉及多个步骤和依赖时，工厂方法模式可以将这些复杂的创建逻辑封装在具体工厂类中。

class ComplexProduct {
    private String part1;
    private String part2;

    public ComplexProduct(String part1, String part2) {
        this.part1 = part1;
        this.part2 = part2;
    }

    public void showDetails() {
        System.out.println("部件1: " + part1);
        System.out.println("部件2: " + part2);
    }
}

abstract class ComplexProductFactory {
    public abstract ComplexProduct createProduct();
}

class ConcreteComplexProductFactory extends ComplexProductFactory {
    @Override
    public ComplexProduct createProduct() {
        String part1 = "部件A";
        String part2 = "部件B";
        return new ComplexProduct(part1, part2);
    }
}

public class ComplexProductClient {
    public static void main(String[] args) {
        ComplexProductFactory factory = new ConcreteComplexProductFactory();
        ComplexProduct product = factory.createProduct();
        product.showDetails();
    }
}

最佳实践

提高代码的可维护性

将对象创建逻辑封装在工厂类中，使得客户端代码只关心如何使用对象，而不关心对象的创建细节。这样当对象创建逻辑发生变化时，只需要修改工厂类，而不需要修改大量的客户端代码。

增强代码的可扩展性

通过使用工厂方法模式，可以方便地添加新的产品和工厂类，而不会影响到现有代码的结构。这使得系统能够轻松应对业务需求的变化。

小结

工厂方法模式是Java开发中一种强大的创建型设计模式，它通过将对象的创建和使用分离，提高了代码的可维护性和可扩展性。在实际开发中，我们可以根据具体需求选择简单工厂模式或工厂方法模式，并结合多态性和复杂对象创建的实践，写出更加优雅和高效的代码。

参考资料

《设计模式 - 可复用的面向对象软件元素》（Erich Gamma、Richard Helm、Ralph Johnson、John Vlissides 著）
《Effective Java》（Joshua Bloch 著）
Oracle Java Documentation