Java 中什么是工厂模式？

推荐答案

工厂模式是一种创建型设计模式，它提供了一种创建对象的方式，而无需指定具体的类。工厂模式通过定义一个接口或抽象类来创建对象，但将具体的实例化过程推迟到子类或工厂类中。这样，客户端代码只需要与工厂接口交互，而不需要知道具体的实现类。

在Java中，工厂模式通常分为三种类型：

1. 简单工厂模式：通过一个工厂类来创建不同类型的对象。
2. 工厂方法模式：定义一个创建对象的接口，但由子类决定实例化哪个类。
3. 抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体的类。

本题详细解读

简单工厂模式

简单工厂模式是最基础的工厂模式，它通过一个工厂类来创建不同类型的对象。客户端只需要传递一个参数给工厂类，工厂类根据参数返回相应的对象。

// www.javascriptcn.com code example
public class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ProductA();
        } else if (type.equals("B")) {
            return new ProductB();
        }
        return null;
    }
}

interface Product {
    void use();
}

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

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

工厂方法模式

工厂方法模式定义了一个创建对象的接口，但由子类决定实例化哪个类。工厂方法模式将对象的实例化推迟到子类。

// www.javascriptcn.com code example
public abstract class Factory {
    public abstract Product createProduct();

    public void useProduct() {
        Product product = createProduct();
        product.use();
    }
}

class FactoryA extends Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

class FactoryB extends Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

抽象工厂模式

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体的类。抽象工厂模式通常用于创建一组相关的对象。

// www.javascriptcn.com code example
public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}

class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB2();
    }
}

interface ProductA {
    void use();
}

interface ProductB {
    void use();
}

class ProductA1 implements ProductA {
    @Override
    public void use() {
        System.out.println("Using Product A1");
    }
}

class ProductA2 implements ProductA {
    @Override
    public void use() {
        System.out.println("Using Product A2");
    }
}

class ProductB1 implements ProductB {
    @Override
    public void use() {
        System.out.println("Using Product B1");
    }
}

class ProductB2 implements ProductB {
    @Override
    public void use() {
        System.out.println("Using Product B2");
    }
}

通过工厂模式，客户端代码与具体类的实现解耦，提高了代码的灵活性和可维护性。