Java工厂模式详解：方法工厂模式与抽象工厂模式

一、引言

在Java开发中，设计模式是解决常见软件设计问题的一种有效方式。工厂模式作为创建型设计模式的一种，提供了灵活的对象创建机制，有助于降低代码的耦合度，提高系统的可维护性和可扩展性。本文将详细介绍Java中的方法工厂模式（Factory Method Pattern）和抽象工厂模式（Abstract Factory Pattern）。

二、方法工厂模式

2.1 定义

方法工厂模式（Factory Method Pattern）是一种创建型设计模式，它定义了一个用于创建对象的接口，但让子类决定要实例化的类是哪一个。工厂方法让类的实例化推迟到子类中进行。

2.2 结构

方法工厂模式主要包含以下几个角色：

抽象工厂角色（Creator）：声明了工厂方法，用于返回一个产品对象。
具体工厂角色（Concrete Creator）：实现了抽象工厂角色中的工厂方法，用于返回一个具体的产品对象。
抽象产品角色（Product）：定义了产品的接口，是工厂方法所创建对象的超类型，也就是产品对象的共同接口。
具体产品角色（Concrete Product）：实现了抽象产品角色所定义的接口，由具体工厂角色创建，客户端通过抽象产品角色使用具体产品。

2.3 优点

可扩展性：当需要增加新的产品时，只需要增加相应的具体产品类和具体工厂类，无需修改现有代码。
解耦：将产品的创建与使用分离，客户端只需要知道产品接口，而无需知道具体产品的类名。

2.4 缺点

增加类的数量：每增加一个产品，都需要增加一个具体产品类和一个具体工厂类，增加了系统的复杂性。

2.5 代码示例

java 复制代码

// 抽象产品角色
public interface Product {
    void doSomething();
}

// 具体产品A
public class ProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("A do Something");
    }
}

// 具体产品B
public class ProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("B do Something");
    }
}

// 抽象工厂角色
public abstract class Factory {
    abstract Product create();
}

// 具体工厂A
public class FactoryA extends Factory {
    @Override
    Product create() {
        return new ProductA();
    }
}

// 具体工厂B
public class FactoryB extends Factory {
    @Override
    Product create() {
        return new ProductB();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Factory factory = new FactoryA();
        Product product = factory.create();
        product.doSomething();

        factory = new FactoryB();
        product = factory.create();
        product.doSomething();
    }
}

三、抽象工厂模式

3.1 定义

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

3.2 结构

抽象工厂模式主要包含以下几个角色：

抽象工厂角色（Abstract Factory）：声明了一组用于创建产品的抽象方法。
具体工厂角色（Concrete Factory）：实现了抽象工厂角色中的抽象方法，用于创建具体的产品对象。
抽象产品角色（Abstract Product）：定义了产品的接口，是工厂方法所创建对象的超类型。
具体产品角色（Concrete Product）：实现了抽象产品角色所定义的接口，由具体工厂角色创建。

3.3 优点

封装性：客户端只需要知道产品的抽象类型，无需关心具体产品的实现细节。
可扩展性：当需要增加新的产品族时，只需要增加相应的具体产品类和具体工厂类，无需修改现有代码。
灵活性：可以在不修改客户端代码的情况下更换产品族。

3.4 缺点

增加系统的复杂性：由于涉及到多个抽象层，增加了系统的理解和维护难度。

3.5 代码示例

java 复制代码

// 抽象产品A
public interface Engine {
    void run();
    void start();
}

// 具体产品A1
public class LuxuryEngine implements Engine {
    @Override
    public void run() {
        System.out.println("转的快");
    }

    @Override
    public void start() {
        System.out.println("启动快!可以自动启停!");
    }
}

// 抽象产品B
public interface Seat {
    void massage();
}

// 具体产品B1
public class LuxurySeat implements Seat {
    @Override
    public void massage() {
        System.out.println("可以自动按摩");
    }
}

// 抽象工厂角色
public interface CarFactory {
    Engine createEngine();
    Seat createSeat();
}

// 具体工厂A
public class LuxuryCarFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new LuxuryEngine();
    }

    @Override
    public Seat createSeat() {
        return new LuxurySeat();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        CarFactory factory = new LuxuryCarFactory();
        Engine engine = factory.createEngine();
        engine.run();
        engine.start();

        Seat seat = factory.createSeat();
        seat.massage();
    }
}

四、总结

方法工厂模式和抽象工厂模式都是用于创建对象的设计模式，但它们的应用场景和侧重点不同。方法工厂模式侧重于单个对象的创建，通过子类决定实例化哪个类；而抽象工厂模式则侧重于创建一系列相关或相互依赖的对象，通过接口来定义一组产品的创建方法。在实际开发中，应根据具体需求选择合适的设计模式。