设置模式之工厂模式

1.简单工厂模式
如果我们在添加新的品种咖啡,那我们 又要改 工厂里面的方法,违背了代码封闭原则
这个相当于 又当老板 又当工人 (生意不好的时候,就可能只针对一个人来服务)

// 简单工厂模式
class Coffee {
    constructor(name) {
        console.log("你点的咖啡是" + name);
    }
}

class LateCoffee extends Coffee {

}

class NestleCoffee extends Coffee {
    
}

class AmericanoCoffee extends Coffee {
    
}

// 这里创建一个工厂
class CoffeeFactory {
    // 创建一个咖啡
    static createCoffee(type) {
        switch (type) {
            case 'Late': 
            return new LateCoffee("拿铁");
            case 'Nestle': 
            return new LateCoffee("雀巢");
            case 'Americano': 
            return new LateCoffee("美式");
            default:
                throw new Error("我们工厂 不支持 你点的咖啡");
        }
    }
}
// 如果是静态方法, static定义的 不需要new 关键字就可以 直接调用
CoffeeFactory.createCoffee('Late');
CoffeeFactory.createCoffee('Nestle');
CoffeeFactory.createCoffee('Americano');
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

2.工厂模式
这个相当于 我们当老板, 去招聘对用的厨师和去新建厨师对应的工厂
(这个就是生意好的时候,一个人忙不过来,就请人和给请的人一个专门的工厂,每个人在工厂里做自己的事情)

// 工厂模式

class Coffee {
    constructor(name) {
        console.log("你点的咖啡是" + name);
    }
}

class LateCoffee extends Coffee {
}

class NestleCoffee extends Coffee {
}

class AmericanoCoffee extends Coffee {
}

// 这里创建一个工厂
class CoffeeFactory {
    // 这个是工厂的创建方法
    createCoffee() {

    }
}

// 这个是来继承工厂的东西
class LateCoffeeFactory extends CoffeeFactory{
    createCoffee() {
       return new  LateCoffee("拿铁咖啡");
    }
}

// 这个是来继承工厂的东西
class NestleCoffeeFactory extends CoffeeFactory{
    createCoffee() {
        return new  LateCoffee("雀巢咖啡");
     }
}

// 这个是来继承工厂的东西
class AmericanoCoffeeFactory extends CoffeeFactory{
    createCoffee() {
        return new  LateCoffee("美式咖啡");
    }
}

new LateCoffeeFactory().createCoffee();
new NestleCoffeeFactory().createCoffee();
new AmericanoCoffeeFactory().createCoffee();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

3.抽象类工厂
简单来说 就是我们有两个店(星巴克跟雀巢店),我们每一个店里面都有(拿铁,雀巢,美式咖啡),虽然是每个店都有这个咖啡,
但是每个店里面的的制作咖啡都是不一样的
(这个就是生意爆好的情况,相当于开连锁店的情况,每个连锁店里面都有自己的产品)

class Coffee {
    constructor(name) {
        console.log("我是"+name);
    }
}
// 这个是咖啡的类型
class LateCoffee extends Coffee {}

class NestleCoffee extends Coffee  {}

class AmericanoCoffee extends Coffee {}

// 这里就是创建6个品种的咖啡, 星巴克 跟雀巢店都有的三个咖啡
class XingBaKeLateCoffee extends LateCoffee {}
class XingBaKeNestleCoffee extends NestleCoffee {}
class XingBaKeAmericanoCoffee extends AmericanoCoffee {}

// 这个是 雀巢店的咖啡
class QueChaoLateCoffee extends LateCoffee{}
class QueChaoNestleCoffee extends NestleCoffee {}
class QueChaoAmericanoCoffee extends AmericanoCoffee {}

class Factory {
    createLateCoffee() {};

    createNestleCoffee() {}

    createAmericanoCoffee() {}
}


//这个是星巴克的工厂
class XinBaKeCoffeeFactory extends Factory{
    createLateCoffee() {
        return new  XingBaKeLateCoffee("星巴克拿铁咖啡");
    }

    createNestleCoffee() {
        return new  XingBaKeNestleCoffee("星巴克雀巢咖啡");
    }

    createAmericanoCoffee() {
        return new  XingBaKeAmericanoCoffee("星巴克美式咖啡");
    }
}


//这个是雀巢的工厂
class QueChaoCoffeeFactory extends Factory {
    createLateCoffee() {
        return new  QueChaoLateCoffee("雀巢店拿铁咖啡");
    }

    createNestleCoffee() {
        return new  QueChaoNestleCoffee("雀巢店雀巢咖啡");
    }

    createAmericanoCoffee() {
        return new  QueChaoAmericanoCoffee("雀巢店美式咖啡");
    }
}


// 这个样子 就是每个店都有 自己单独的coffee
// 星巴克 部分
new XinBaKeCoffeeFactory().createLateCoffee();
new XinBaKeCoffeeFactory().createNestleCoffee();
new XinBaKeCoffeeFactory().createAmericanoCoffee();

//雀巢店
new QueChaoCoffeeFactory().createLateCoffee();
new QueChaoCoffeeFactory().createNestleCoffee();
new QueChaoCoffeeFactory().createAmericanoCoffee();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

结果是:

抽象类我们在放一个好理解的图