TS设计模式之三种工厂模式

无穷小白

于 2024-02-26 09:03:28 发布

阅读量734

点赞数 8

文章标签：设计模式抽象工厂模式简单工厂模式 typescript 工厂方法模式

本文链接：https://blog.csdn.net/m0_51478473/article/details/136253879

版权

1.简单工厂模式

简单工厂模式顾名思义，其意思为像工厂一样机械化生产和创建相应的类，接下来我将通过具象化例子来解释。

假设我们现在有一家宠物玩具工厂，我们工厂现在又两条流水线，一条流水线专门生产猫玩偶，一条流水线专门生产狗玩偶，代码实现如下

1. 第一步，我们创建一个工厂类，该类通过调用createAnimal方法生产猫玩偶或狗玩偶

class Factory {
    static createAnimal(type: string):any {
        switch (type) {
            case 'dog':
                return new Dog(3, '黑色')
            case 'cat':
                return new Cat(20, '白色')
            default:
                return null
        }
    }
}

2.第二步，创建猫玩偶类和狗玩偶类当作两条流水线

class Dog {
    age: number;
    color: string;

    constructor(age: number, color: string) {
        this.age = age
        this.color = color
    }

    play(): void {
        console.log(`玩球`)
    }
}

class Cat {
    height: number;
    color: string;

    constructor(height: number, color: string) {
        this.height = height
        this.color = color
    }

    say(): void {
        console.log(`喵喵喵`)
    }
}

3.第三步，通过工厂类的静态方法createAnimal传入不同类型生产不同玩偶

const huahua  =Factory.createAnimal('dog')
const fugui = Factory.createAnimal('dog')
const mimi = Factory.createAnimal('cat')
const zhaocai = Factory.createAnimal('cat')
const xiaohei = Factory.createAnimal('cat')
const gray = Factory.createAnimal('cat')

优点：

1.简单工厂模式又被称为上帝模式，工厂需要添加什么产品只需要添加一个类即可。

缺点：

1.当需要的产品越来越多，需要引入的类也会越来越多。

2.该模式不符合开闭原则（OCP），需要新增一个产品时要改变工厂类中的逻辑。

2. 工厂方法模式

工厂方法模式在工厂模式的基础上满足了开闭原则，工厂不再直接负责生产产品，而是把工厂变为一个抽象类，每增加一个产品只需要继承工厂的抽象类返回不同产品即可，因为产品的不同，定义了一个接口，若需要新增一个产品只需重写一次接口即可，代码实现过程如下。

1. 抽象工厂类

abstract class Creator {
    abstract product(): Product

    someOpera():Product {
        return this.product()
    }
}

2. 继承抽象工厂类

class CatCreator extends Creator {
    product(): Product {
        return new Cat(40,'灰色');
    }
}

class CarCreator extends Creator {
    product(): Product {
        return new Car();
    }

}

3. 产品接口和产品类

interface Product {
    someOpera(): void
}

class Cat implements Product {
    height: number
    color: string
    constructor(height: number, color: string) {
        this.color = color
        this.height = height
    }
    someOpera() {
    }

    say() {
        console.log('喵喵喵')
    }
}

class Car implements Product {
    someOpera(): void {
    }
    move() {
        console.log('嘟嘟')
    }
}

优点：

1.满足了开闭原则，添加一个产品不需要修改源代码

缺点：

1.添加一个产品要修改很多代码

3. 抽象工厂模式

在生产电脑时，组装电脑需要不同品牌的零部件，在抽象工厂模式中，将所有的零部件和生产零部件的工厂都抽象为一个接口，若需要生产A品牌的零部件，只需要A品牌的零部件去实现对应的接口。生产A品牌电脑的工厂去实现对应的工厂接口即可生产。将其拓展到代码中实现为，现在需要生产A品牌的电脑，电脑中含有主板和CPU，我们先定义一个主板的接口AbstractMain， CPU接口 AbstractCpu，对应的A品牌主板和CPU实现这两个接口，MainA ， CpuA，创建一个工厂接口AbstractFactory，里面定义生产CPU和主板的方法，创建FactoryA类实现AbstractFactory接口，通过调用FactoryA工厂即可创建A品牌电脑

// 主板的抽象接口
interface AbstractMain {
    save(): void
}

// A品牌的主板
class MainA implements AbstractMain {
    save(): void {
        console.log('A主板进行存储')
    }
}

// B品牌的主板
class MainB implements AbstractMain {
    save(): void {
        console.log('B主板进行存储')
    }
}

// CPU的抽象接口
interface AbstractCPU {
    computed(): void
}

// A品牌的CPU
class CpuA implements AbstractCPU {
    computed(): void {
        console.log('A Cpu进行计算')
    }

}

// B品牌的CPU
class CpuB implements AbstractCPU {
    computed(): void {
        console.log('B Cpu进行计算')
    }
}

// 电脑工厂的抽象接口
interface AbstractFactory {
    createCpu(): AbstractCPU
    createMain(): AbstractMain
}

// 生产A品牌的电脑类
class FactoryA implements AbstractFactory {
    createCpu(): AbstractCPU {
        return new CpuA();
    }

    createMain(): AbstractMain {
        return new MainA();
    }
}

// 生产B品牌的电脑类
class FactoryB implements AbstractFactory {
    createCpu(): AbstractCPU {
        return new CpuB();
    }

    createMain(): AbstractMain {
        return new MainB();
    }
}

export default class MainFactory {
    static createComputerA() {
        return new FactoryA()
    }
    static createComputerB() {
        return new FactoryB()
    }
}