GameTech设计模式

工厂模式(FactoryPattern)

利用静态工厂则不需要使用创建对象的方法来实例化对象，但不能通过继承来改变创建方法的行为

简单工厂

简单工厂不是一个设计模式而是更像一种编程习惯

利用一个工厂类去创建并返回一个具体实例对象

适用于创建单一的对象类型

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
74
75
public class Pizza
{

    public void Box()
    {
        throw new NotImplementedException();
    }

    public void Cut()
    {
        throw new NotImplementedException();
    }

    public void Bake()
    {
        throw new NotImplementedException();
    }

    public void Prepare()
    {
        throw new NotImplementedException();
    }

}

class PizzaStore
{
    SimplePizzaFactory factory;

    public PizzaStore(SimplePizzaFactory factory)
    {
        this.factory = factory;
    }
    
    Pizza OrderPizza(String type)
    {
        Pizza pizza;
        pizza = factory.CreatPizza(type);
        
        pizza.Prepare();
        pizza.Bake();
        pizza.Cut();
        pizza.Box();
        
        return pizza;
    }
}

public class SimplePizzaFactory
{
    public Pizza CreatPizza(String type)
    {
        Pizza pizza = null!;
        if (type.Equals("cheese"))
        {
            pizza = new CheesePizza();
        }
        else if (type.Equals("Clam"))
        {
            pizza = new ClamPizza();
        }
        
        return pizza;
    }
}

public class CheesePizza : Pizza
{

}

public class ClamPizza : Pizza
{
    
}

工厂模式

拓展简单工厂模式的模式 定义一个工厂方法接口用于创建对象 由子类去决定实例化哪一个类 工厂方法让类把实例化推迟到子类

用于创建不同的对象类型 每个对象类型对应一个工厂方法

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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
public abstract class Pizza
{
    public String name;
    public String dougth;
    public String sauce;
    public ArrayList topPings = new ArrayList();

    public void Prepare()
    {
        Console.WriteLine("Preparing " + name);
        Console.WriteLine("Tossing dough..");
        Console.WriteLine("Adding sauce");
        Console.WriteLine("Adding toppings：");
        for (int i = 0; i < topPings.Count; i++)
        {
            Console.WriteLine("   " + topPings[i]);
        }
    }
    
    public void Box()
    {
        Console.WriteLine("boxing");
    }

    public void Cut()
    {
        Console.WriteLine("cutting");
    }

    public void Bake()
    {
        Console.WriteLine("baking");
    }

    public String GetName()
    {
        return name;
    }
}

public class NYPizza : Pizza
{
    public NYPizza()
    {
        name = "NYPizza";
        dougth = "Crust";
        sauce = "Marinara";

        topPings.Add("Cheese");
    }
}

public abstract class PizzaStore
{
    public Pizza OrderPizza(String type)
    {
        Pizza pizza;
        pizza = CreatPizza(type);

        pizza.Prepare();
        pizza.Bake();
        pizza.Cut();
        pizza.Box();
        
        return pizza;
    }

    protected abstract Pizza CreatPizza(String type);
}

public class NYPizzaStore : PizzaStore
{
    Pizza Pizza;
    protected override Pizza CreatPizza(string type)
    {
        if (type.Equals("Cheese"))
            return Pizza = new NYPizza();
        else
            return Pizza = new NYPizza();
    }
}

public class PizzaTestDrive
{
    static void Main(string[] args)
    {
        PizzaStore nyStore = new NYPizzaStore();
        Pizza pizza = nyStore.OrderPizza("Cheese");
        Console.WriteLine("a：" + pizza.GetName());
    }
}

优点：将产品的实现从使用中解耦

设计原则 六

依赖倒置原则：要依赖抽象 不要依赖具体类

避免违反依赖倒置原则（尽量达到，而非必须）：
变量不可以持有具体类的引用
不要让类派生自具体类
不要覆盖基类中已实现的方法

类与对象：对象是对客观事物的抽象，类是对对象的抽象。类是一种抽象的数据类型。它们的关系是，对象是类的实例，类是对象的模板。对象是通过new classname产生的，用来调用类的方法;类的构造方法 。

工厂方法与抽象工厂：

抽象工厂与工厂方法都是负责创建对象，工厂方法利用继承，抽象工厂利用对象的组合

抽象工厂可以将一群相关的产品集合起来

抽象工厂创建产品的方法通常是以工厂方法来实现

抽象工厂的扩展需要改变接口

说些什么吧！

waline