Java中的工厂模式：简单工厂、工厂方法与抽象工厂

工厂模式是一种常见的软件设计模式，用于创建对象而不需要通过new关键字直接实例化。在Java中，有三种主要的工厂模式：简单工厂、工厂方法和抽象工厂。本文将详细介绍这三种工厂模式的概念、使用场景和代码示例。

1. 简单工厂（Simple Factory）

简单工厂模式（Simple Factory）又称为静态工厂模式，它是最简单的工厂模式。简单工厂模式定义了一个工厂类，根据不同的条件来创建不同的对象。这种模式的核心是由工厂类来决定创建哪一种产品类的实例。

使用场景：

• 需要创建的对象较少，客户端只需要传入类名或枚举值即可。
• 客户端不需要关心对象的创建过程。

代码示例：

首先，创建一个产品接口 Product：

public interface Product {
    void use();
}

然后，创建两个具体产品类 ProductA 和 ProductB：

public class ProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用产品 A");
    }
}

public class ProductB implements Product {
    @Override
    public void use() {
         System.out.println("使用产品 B");
    }
}

接下来，创建一个简单工厂类 SimpleFactory：

public class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equalsIgnoreCase("A")) {
            return new ProductA();
        } else if (type.equalsIgnoreCase("B")) {
            return new ProductB();
        }
        throw new IllegalArgumentException("Unknown product type: " + type);
    }
}

最后，客户端使用简单工厂来创建产品对象：

public static void main(String[] args) {
    Product productA = SimpleFactory.createProduct("A");
    productA.use();
    
    Product productB = SimpleFactory.createProduct("B");
    productB.use();
}

输出结果：

使用产品 A
使用产品 B

2. 工厂方法（Factory Method）

工厂方法模式（Factory Method）定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。

使用场景：

• 需要创建一个产品的对象，但不知道具体实现类的类型。
• 需要扩展产品对象的创建，同时避免修改现有代码。

代码示例：

首先，创建一个产品接口 Product：

public interface Product {
    void use();
}

然后，创建两个具体产品类 ProductA 和 ProductB，实现 Product 接口：

public class ProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用产品 A");
    }
}

public class ProductB implements Product {
    @Override
    public void use() {
        System.out.println("使用产品 B");
    }
}

接下来，创建一个工厂接口 Factory：

public interface Factory {
    Product createProduct();
}

然后，创建两个具体工厂类 ProductAFactory 和 ProductBFactory，分别实现 Factory 接口：

public class ProductAFactory implements Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

public class ProductBFactory implements Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

最后，客户端使用工厂方法来创建产品对象：

public class Main {
    public static void main(String[] args) {
        Factory factoryA = new ProductAFactory();
        Product productA = factoryA.createProduct();
        productA.use();
        
        Factory factoryB = new ProductBFactory();
        Product productB = factoryB.createProduct();
        productB.use();
    }
}

输出结果：

使用产品 A
使用产品 B

3. 抽象工厂（Abstract Factory）

抽象工厂模式（Abstract Factory）提供一个创建相关或依赖对象的接口，而无需指定它们具体的类。抽象工厂的方法通常是以工厂方法为返回值的工厂方法。

使用场景：

• 需要创建一系列相关或依赖对象的组合。
• 需要提供一个产品类的库，客户端只需要知道如何使用抽象工厂和产品接口即可。

代码示例：

首先，创建两个产品族的接口 Product1 和 Product2：

public interface Product1 {
    void use();
}

public interface Product2 {
    void consume();
}

然后，分别创建两个具体产品族的实现类 ConcreteProduct1A、ConcreteProduct1B 和 ConcreteProduct2A、ConcreteProduct2B：

public class ConcreteProduct1A implements Product1 {
    @Override
    public void use() {
        System.out.println("使用 产品1A");
    }
}

public class ConcreteProduct1B implements Product1 {
    @Override
    public void use() {
        System.out.println("使用 产品1B");
    }
}

public class ConcreteProduct2A implements Product2 {
    @Override
    public void consume() {
        System.out.println("消费 产品2A");
    }
}

public class ConcreteProduct2B implements Product2 {
    @Override
    public void consume() {
        System.out.println("消费 产品2B");
    }
}

接下来，创建一个抽象工厂接口 AbstractFactory：

public interface AbstractFactory {
    Product1 createProduct1();
    Product2 createProduct2();
}

然后，创建两个具体抽象工厂类 ConcreteFactoryA 和 ConcreteFactoryB，分别实现 AbstractFactory 接口：

public class ConcreteFactoryA implements AbstractFactory {
    @Override
    public Product1 createProduct1() {
        return new ConcreteProduct1A();
    }
    
    @Override
    public Product2 createProduct2() {
        return new ConcreteProduct2A();
    }
}

public class ConcreteFactoryB implements AbstractFactory {
    @Override
    public Product1 createProduct1() {
        return new ConcreteProduct1B();
    }
    
    @Override
    public Product2 createProduct2() {
        return new ConcreteProduct2B();
    }
}

最后，在客户端中使用抽象工厂创建产品对象：

public class Main {
    public static void main(String[] args) {
        AbstractFactory factoryA = new ConcreteFactoryA();
        Product1 product1A = factoryA.createProduct1();
        Product2 product2A = factoryA.createProduct2();
        
        product1A.use();
        product2A.consume();
        
        AbstractFactory factoryB = new ConcreteFactoryB();
        Product1 product1B = factoryB.createProduct1();
        Product2 product2B = factoryB.createProduct2();
        
        product1B.use();
        product2B.consume();
    }
}

输出结果：

使用 产品1A
消费 产品2A
使用 产品1B
消费 产品2B

总结

工厂模式是一种常见的设计模式，通过将对象的创建过程封装到工厂类中，可以使客户端代码更加简洁、可维护和可扩展。在Java中，有三种主要的工厂模式：简单工厂、工厂方法和抽象工厂。根据不同的需求，选择合适的工厂模式可以提高代码的可读性和可维护性。希望本文对你理解和应用工厂模式有所帮助！

本文来自极简博客，作者：倾城之泪，转载请注明原文链接：Java中的工厂模式：简单工厂、工厂方法与抽象工厂