Edit(2023 3.10) :前几天上设计模式课,老师说了这么一句话，在此记录：

​ 设计模式就是把变化的抽象出来

工厂模式在游戏制作中也是广泛应用，目的在于解耦创建者和被创建者。

在此自己手写我们的可乐工厂加深理解,可乐对象结构如下

1
2
3
4
5
6
7
8
9
10
11
public interface Cola{}

//百事
public class Pepsi :Cola
{  }
//可口
public class Coke :Cola
{ }
//健怡
public class Diet :Cola
{ }

简单工厂

  • 静态简单工厂：无需创建工厂实例，switch实现

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    public class ColaFactory
    {
        public static Cola CreateCola(string name)
        {
            switch (name)
            {
                case "Coke": return new Coke();
                case "Pepsi": return new Pepsi();
                case "Diet": return new Diet();
                default: throw new Exception();
            }
        }
    }

  • 泛型简单工厂

    1
    2
    3
    4
    5
    6
    7
    public class ColaCreator<T> where T : Cola, new()
    {
        public T CreateCola()
        {
            return new T();
        }
    }

  • 缺点：无法具体处理不同类型可乐的初始化参数

普通工厂

新加条件，百事可乐有瓶装罐装之分，容量,价格,风味各不相同,如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Pepsi :Cola
{	
    string tag;
    int capacity;
    float price;
    int flavour;
    public Pepsi(string tag="can", int capacity=300, float price=2.5f, int flavour = 0) 
    {  
        this.tag = tag;
        this.capacity = capacity;
        this.price = price;
        this.flavour = flavour;
    }
}

此时简单工厂将无法满足需求，改为如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public abstract class ColaCreator<T> where T : Cola
{
    public abstract T CreateBottleCola();
    public abstract T CreateCanCola();
}

public class PepsiFactory : ColaCreator<Pepsi>
{
    public override Pepsi CreateBottleCola()
    {
         return new Pepsi(tag:"bottle",capacity: 600, price: 3f);
    }

    public override Pepsi CreateCanCola()
    {
        return new Pepsi();
    }
}

抽象工厂

抽象工厂目的在于帮助工厂处理一系列相关的对象，而不同于普通工厂专注创建一个对象的实例。

新加条件，现在需要两个工厂A,B分别创建联合装可乐A,B，联合装A包含健怡可乐，可口可乐和罐装百事，联合装B只包含健怡可乐和可口可乐。

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
//抽象工厂 工厂一对多，要处理一系列相关的对象
public abstract class AbstractFactory
{
    public abstract Pepsi CreatePepsi();
    public abstract Coke CreateCoke();
    public abstract Diet CreateDiet();
}

//A
public class ColaFactoryA : AbstractFactory
{
    public override Coke CreateCoke()
    {
        return new Coke();
    }

    public override Diet CreateDiet()
    {
        return new Diet();
    }

    public override Pepsi CreatePepsi()
    {
        return new Pepsi(capacity: 600, price: 3f); new mbox
    }
}
//B
public class ColaFactoryB : AbstractFactory
{
    public override Coke CreateCoke()
    {
        return new Coke();
    }

    public override Diet CreateDiet()
    {
        return new Diet();
    }

    public override Pepsi CreatePepsi()
    {
        return null;
    }
}