🤍 前端开发工程师、技术日更博主、已过CET6
🍨 阿珊和她的猫_CSDN博客专家、23年度博客之星前端领域TOP1
🕠 牛客高级专题作者、打造专栏《前端面试必备》 、《2024面试高频手撕题》、《前端求职突破计划》
🍚 蓝桥云课签约作者、上架课程《Vue.js 和 Egg.js 开发企业级健康管理项目》、《带你从入门到实战全面掌握 uni-app》

引言

在软件开发的世界里，对象创建是一项基础且频繁的操作。然而，随着项目规模的扩大和需求的复杂化，直接在代码中创建对象会带来诸多问题，比如代码耦合度高、可维护性差等。工厂模式作为一种强大的创建型设计模式，能够很好地解决这些问题。它将对象的创建和使用分离，为代码带来更高的灵活性和可扩展性。本文将深入探讨工厂模式的原理、不同类型的实现方式，并通过手写代码示例展示其应用。

工厂模式的基本概念

工厂模式的核心思想是将对象的创建逻辑封装在一个专门的工厂类或函数中，而不是在客户端代码中直接实例化对象。客户端只需要向工厂提供必要的信息，工厂就会根据这些信息创建并返回合适的对象。这样做的好处是，当对象的创建逻辑发生变化时，只需要修改工厂类，而不会影响到客户端代码，从而降低了代码之间的耦合度。

工厂模式主要有三种类型：简单工厂模式、工厂方法模式和抽象工厂模式。下面我们将分别介绍这三种模式的实现。

简单工厂模式

原理

简单工厂模式是工厂模式中最基础的一种。它通过一个工厂类来负责创建所有类型的对象。工厂类通常包含一个创建对象的方法，该方法根据传入的参数来决定创建哪种类型的对象。

代码实现

// 抽象产品类：交通工具
class Vehicle {
    move() {
        throw new Error('move method must be implemented');
    }
}

// 具体产品类：汽车
class Car extends Vehicle {
    move() {
        console.log('Car is moving on the road.');
    }
}

// 具体产品类：飞机
class Plane extends Vehicle {
    move() {
        console.log('Plane is flying in the sky.');
    }
}

// 简单工厂类
class VehicleFactory {
    static createVehicle(type) {
        switch (type) {
            case 'car':
                return new Car();
            case 'plane':
                return new Plane();
            default:
                throw new Error('Invalid vehicle type');
        }
    }
}

// 使用示例
const car = VehicleFactory.createVehicle('car');
car.move(); 

const plane = VehicleFactory.createVehicle('plane');
plane.move(); 

代码解释

• Vehicle 是抽象产品类，定义了一个抽象方法 move，具体的交通工具类需要实现这个方法。
• Car 和 Plane 是具体产品类，分别实现了 move 方法，描述了汽车和飞机的移动方式。
• VehicleFactory 是简单工厂类，其 createVehicle 方法根据传入的 type 参数，决定创建并返回哪种交通工具对象。

工厂方法模式

原理

工厂方法模式在简单工厂模式的基础上进行了改进。它将创建对象的逻辑进一步抽象，定义了一个抽象的工厂类，其中包含一个抽象的创建对象方法。具体的工厂子类负责实现这个方法，从而创建不同类型的对象。

代码实现

// 抽象产品类：食物
class Food {
    taste() {
        throw new Error('taste method must be implemented');
    }
}

// 具体产品类：披萨
class Pizza extends Food {
    taste() {
        console.log('Pizza tastes delicious.');
    }
}

// 具体产品类：汉堡
class Hamburger extends Food {
    taste() {
        console.log('Hamburger tastes great.');
    }
}

// 抽象工厂类
class FoodFactory {
    createFood() {
        throw new Error('createFood method must be implemented');
    }
}

// 具体工厂类：披萨工厂
class PizzaFactory extends FoodFactory {
    createFood() {
        return new Pizza();
    }
}

// 具体工厂类：汉堡工厂
class HamburgerFactory extends FoodFactory {
    createFood() {
        return new Hamburger();
    }
}

// 使用示例
const pizzaFactory = new PizzaFactory();
const pizza = pizzaFactory.createFood();
pizza.taste(); 

const hamburgerFactory = new HamburgerFactory();
const hamburger = hamburgerFactory.createFood();
hamburger.taste(); 

代码解释

• Food 是抽象产品类，定义了 taste 方法，具体的食物类需要实现该方法。
• Pizza 和 Hamburger 是具体产品类，分别实现了 taste 方法，描述了披萨和汉堡的口味。
• FoodFactory 是抽象工厂类，定义了抽象的 createFood 方法。
• PizzaFactory 和 HamburgerFactory 是具体工厂类，分别实现了 createFood 方法，用于创建 Pizza 和 Hamburger 对象。

抽象工厂模式

原理

抽象工厂模式提供了一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。它适用于创建对象的家族，每个家族包含多个相关的产品对象。

代码实现

// 抽象产品类：动物
class Animal {
    speak() {
        throw new Error('speak method must be implemented');
    }
}

// 具体产品类：狗
class Dog extends Animal {
    speak() {
        console.log('Dog says: Woof!');
    }
}

// 具体产品类：猫
class Cat extends Animal {
    speak() {
        console.log('Cat says: Meow!');
    }
}

// 抽象产品类：食物
class AnimalFood {
    eat() {
        throw new Error('eat method must be implemented');
    }
}

// 具体产品类：狗粮
class DogFood extends AnimalFood {
    eat() {
        console.log('Dog is eating dog food.');
    }
}

// 具体产品类：猫粮
class CatFood extends AnimalFood {
    eat() {
        console.log('Cat is eating cat food.');
    }
}

// 抽象工厂类
class AnimalFactory {
    createAnimal() {
        throw new Error('createAnimal method must be implemented');
    }

    createFood() {
        throw new Error('createFood method must be implemented');
    }
}

// 具体工厂类：狗工厂
class DogFactory extends AnimalFactory {
    createAnimal() {
        return new Dog();
    }

    createFood() {
        return new DogFood();
    }
}

// 具体工厂类：猫工厂
class CatFactory extends AnimalFactory {
    createAnimal() {
        return new Cat();
    }

    createFood() {
        return new CatFood();
    }
}

// 使用示例
const dogFactory = new DogFactory();
const dog = dogFactory.createAnimal();
const dogFood = dogFactory.createFood();
dog.speak(); 
dogFood.eat(); 

const catFactory = new CatFactory();
const cat = catFactory.createAnimal();
const catFood = catFactory.createFood();
cat.speak(); 
catFood.eat(); 

代码解释

• 定义了 Animal 和 AnimalFood 两个抽象产品类，以及它们的具体实现类。
• AnimalFactory 是抽象工厂类，定义了创建 Animal 和 AnimalFood 对象的抽象方法。
• DogFactory 和 CatFactory 是具体工厂类，分别实现了创建狗和狗食、猫和猫食的方法。

工厂模式的应用场景

• 对象创建逻辑复杂：当对象的创建过程涉及到多个步骤、复杂的条件判断或依赖外部资源时，使用工厂模式可以将这些逻辑封装在工厂类中，使客户端代码更加简洁。
• 创建多种类型对象：如果系统需要创建多种不同类型的对象，并且这些对象具有相同的接口或继承关系，工厂模式可以方便地管理和创建这些对象。
• 解耦对象创建和使用：将对象的创建和使用分离，降低代码之间的耦合度，提高代码的可维护性和扩展性。当需要新增或修改对象的创建逻辑时，只需要修改工厂类，而不会影响到客户端代码。

总结

工厂模式是一种非常实用的设计模式，它通过将对象的创建和使用分离，为代码带来了更高的灵活性和可维护性。简单工厂模式适用于创建对象类型较少且创建逻辑相对简单的场景；工厂方法模式在需要创建多种对象类型且希望将创建逻辑进一步抽象时非常有用；抽象工厂模式则适用于创建一系列相关或相互依赖的对象家族。在实际开发中，根据具体的需求选择合适的工厂模式，可以优化对象的创建过程，提升代码的质量和可扩展性。