1、什么是工厂模式

工厂模式。我们可以从字面意思去理解。工厂：是用于制造物品的场所。所以工厂模式也可以理解为制造“物品”的模式。

通过代入代码理解，我们一般新建一个对象，都是通过new关键字，这种新建对象的方式，需要我们对这个对象有足够的了解，知道初始化这个对象需要哪些资源。而工厂模式便解决了这个问题，它将新建对象的过程放在一个“工厂”里面，我们需要哪个对象，只需要告诉它，它就能帮我们新建好对象返回给我们。

而工厂模式又分为简单工厂、工厂方法、抽象工厂等。

下面我们将通过代码实现来了解这三种工厂模式的区别

2、代码实现

简单工厂

package factory.mode;

public class SimpleFactory {

    public static void main(String[] args) throws ClassNotFoundException {

        // 简单工厂创建类
        Animal cat = AnimalFactory.createAnimal("cat");
        cat.cry();
        Animal dog = AnimalFactory.createAnimal("dog");
        dog.cry();

        // 不使用工厂模式，默认实现
        Animal cat2 = new Cat();
        cat2.cry();
        Animal dog2 = new Dog();
        dog2.cry();

    }

}


// 动物接口
interface Animal {
    void cry();
}

// 猫
class Cat implements Animal {
    @Override
    public void cry() {
        System.err.println("小猫喵喵叫");
    }
}

// 狗
class Dog implements Animal {
    @Override
    public void cry() {
        System.err.println("小狗汪汪叫");
    }
}

// 动物简单工厂
class AnimalFactory{
    public static Animal createAnimal(String type) throws ClassNotFoundException {
        return switch (type.toLowerCase()){
            case "cat" -> new Cat();
            case "dog" -> new Dog();
            default -> throw new ClassNotFoundException("类创建失败，请检查参数是否正确");
        };
    }
}

工厂方法

package factory.mode;

/**
 * @author lmq
 * @version 1.0
 * @describe 工厂方法demo
 * @datetime 2025/3/7 23:58
 **/
public class FactoryMethod {

    public static void main(String[] args) {
        // 工厂方法实现
        CarFactory bmwFactory = new BmwFactory();
        Car bmw = bmwFactory.createCar();
        bmw.start();
        CarFactory porscheFactory = new PorscheFactory();
        Car porsche = porscheFactory.createCar();
        porsche.start();

        // 不使用工厂方法，普通实现
        Car bmw2 = new Bmw();
        bmw2.start();
        Car porsche2 = new Porsche();
        porsche2.start();

    }
}

// 汽车接口
interface Car {
    void start();
}

// 宝马
class Bmw implements Car {
    @Override
    public void start() {
        System.err.println("启动了宝马汽车");
    }
}

// 保时捷
class Porsche implements Car {
    @Override
    public void start() {
        System.err.println("启动了保时捷汽车");
    }
}

// 汽车工厂类
interface CarFactory {
    Car createCar();
}

// 宝马工厂类
class BmwFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Bmw();
    }
}

// 保时捷工厂类
class PorscheFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Porsche();
    }
}

抽象工厂

package factory.mode;

/**
 * @author lmq
 * @version 1.0
 * @describe 抽象工厂demo
 * @datetime 2025/3/8 0:32
 **/
public class AbstractFactory {

    public static void main(String[] args) {

        GUIFactory factory;
        String osName = System.getProperty("os.name").toLowerCase();
        if (osName.contains("windows")){
            factory = new WindowsGUIFactory();
        } else{
            factory = new MacGUIFactory();
        }
        Button button = factory.createButton();
        button.render();

        TextField textField = factory.createTextField();
        textField.display();
    }
}

// 按钮
interface Button {
    void render();
}

// windows按钮
class WinwodsButton implements Button{
    @Override
    public void render() {
        System.err.println("渲染了windows按钮");
    }
}

// mac按钮
class MacButton implements Button{
    @Override
    public void render() {
        System.err.println("渲染了mac按钮");
    }
}

// 文本框
interface TextField{
    void display();
}

// Windows文本框
class WindowsTextField implements TextField{
    @Override
    public void display() {
        System.err.println("展示了windows文本框");
    }
}

// mac文本框
class MacTextField implements TextField{
    @Override
    public void display() {
        System.err.println("展示了Mac文本框");
    }
}

// 抽象工厂类
interface GUIFactory{
    Button createButton();
    TextField createTextField();
}

// windows工厂类
class WindowsGUIFactory implements GUIFactory{
    @Override
    public Button createButton() {
        return new WinwodsButton();
    }
    @Override
    public TextField createTextField() {
        return new WindowsTextField();
    }
}

// mac工厂类
class MacGUIFactory implements GUIFactory{
    @Override
    public Button createButton() {
        return new MacButton();
    }
    @Override
    public TextField createTextField() {
        return new MacTextField();
    }
}

3、总结

• 简单工厂模式适合产品种类不多、变化不大的场景，使用方便但扩展性较差。

• 工厂方法模式通过子类实现产品创建，较好地符合开闭原则，但会增加类的数量。

• 抽象工厂模式适用于产品族的场景，可以保证一组相关产品的一致性，但结构相对复杂，增加新的产品族时修改较多。