本文主要向大家介绍了《Head First 设计模式》C#编程版：工厂模式之抽象工厂，通过具体的内容向大家展示，希望对大家学习

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class FactoryPattern1 : MonoBehaviour {

    void Start() {

        //我们开始正式定披萨了

        NYStylePizzeStore nYStylePizzeStore = new NYStylePizzeStore();

        nYStylePizzeStore.OrderPizza( PIZZETYPE.CHEESE);

        ChicagoStylePizzeStore chicagoStylePizzeStore = new ChicagoStylePizzeStore();

        chicagoStylePizzeStore.OrderPizza( PIZZETYPE.VEGGIE);

    }

}

/*

    抽象工厂模式

        提供一个接口，用于创建相关或者依赖的家族，而不需要指明具体类。

    依赖倒置原则

        1、变量不可以持有具体类的引用

        2、不要让类派生自具体类

        3、不要覆盖基类中已实现的方法

*/

#region 运用依赖倒置原则的工厂模式

/// <summary>

/// 建造披萨原料工厂 接口

/// </summary>

public interface  PizzaIngredientFactory {

    Dough       CreateDough();

    Sauce       CreateSauce();

    Cheese      CreateCheese();

    Veggies[]   CreateVeggies();

    Pepperoni CreatePepperoni();

    Clams       CreateClam();

}

/// <summary>

/// 纽约披萨工厂

/// </summary>

public class NYPizzaIngredientFactory : PizzaIngredientFactory{

    public  Dough CreateDough(){

        return new NYDough();

    }

    public Sauce CreateSauce(){

        return new NYSauce();

    }

    public Cheese CreateCheese(){

        return new NYCheese();

    }

    public Veggies[] CreateVeggies(){

        Veggies[] veggies = { new NYVeggies(),new Onion(),new Garlic()};

        return veggies;

    }

    public Pepperoni CreatePepperoni(){

        return new NYPepperoni();

    }

    public Clams CreateClam(){

        return new NYClams();

    }

}

/// <summary>

/// 芝加哥披萨工厂

/// </summary>

public class ChicagoPizzaIngredientFactory : PizzaIngredientFactory {

    public Dough CreateDough() {

        return new ChicagoDough();

    }

    public Sauce CreateSauce() {

        return new ChicagoSauce();

    }

    public Cheese CreateCheese() {

        return new ChicagoCheese();

    }

    public Veggies[] CreateVeggies() {

        Veggies[] veggies = { new ChicagoVeggies(), new Onion(), new Garlic() };

        return veggies;

    }

    public Pepperoni CreatePepperoni() {

        return new ChicagoPepperoni();

    }

    public Clams CreateClam() {

        return new ChicagoClams();

    }

}

/// <summary>

/// Pizza 抽象类

/// </summary>

public abstract class Pizza {

    public string name;

    /// <summary>

    /// 面团

    /// </summary>

    public Dough dough;

    /// <summary>

    /// 酱汁

    /// </summary>

    public Sauce sauce;

    public Cheese cheese;

    public Veggies[] veggies;

    public Pepperoni pepperoni;

    public Clams clams;

    /// <summary>

    /// 披萨准备流程

    /// </summary>

    public abstract void Prepare();

    public virtual void Back() {

        Debug.Log("烧烤 25分钟");

    }

    public virtual void Cut() {

        Debug.Log("切片  圆形");

    }

    // C# 重写改方法 必须在父类中加上 virtual  子类中使用 override

    public virtual void Box() {

        Debug.Log("包装  普通披萨标准");

    }

    public virtual void SetName(string name){

        this.name = name;

    }

    public string GetName() {

        return name;

    }

    public virtual string ToStringPizze(){

        return "";

    }

}

/// <summary>

/// 奶酪披萨

/// </summary>

public class CheesePizze : Pizza{

    PizzaIngredientFactory pizzaIngredientFactory;

    public CheesePizze(PizzaIngredientFactory pizzeF){

        this.pizzaIngredientFactory = pizzeF;

        this.SetName(" 奶酪披萨  ");

    }

    public override void Prepare() {

        Debug.Log(" Prepare " + GetName());

        dough = pizzaIngredientFactory.CreateDough();

        sauce = pizzaIngredientFactory.CreateSauce();

        cheese = pizzaIngredientFactory.CreateCheese();

    }

    public override void Box() {

        Debug.Log("包装  纽约披萨标准");

    }

}

/// <summary>

/// 蛤蜊披萨

/// </summary>

public class ClamPizze : Pizza {

    PizzaIngredientFactory pizzaIngredientFactory;

    public ClamPizze(PizzaIngredientFactory pizzeF) {

        this.pizzaIngredientFactory = pizzeF;

        this.SetName(" 蛤蜊披萨  ");

    }

    public override void Prepare() {

        Debug.Log(" Prepare " + GetName());

        dough = pizzaIngredientFactory.CreateDough();

        sauce = pizzaIngredientFactory.CreateSauce();

        cheese = pizzaIngredientFactory.CreateCheese();

        clams = pizzaIngredientFactory.CreateClam();

    }

}

/// <summary>

/// 蔬菜披萨

/// </summary>

public class VeggiePizze : Pizza {

    PizzaIngredientFactory pizzaIngredientFactory;

    public VeggiePizze(PizzaIngredientFactory pizzeF) {

        this.pizzaIngredientFactory = pizzeF;

        this.SetName(" 蔬菜披萨  ");

    }

    public override void Prepare() {

        Debug.Log(" Prepare " + GetName());

        dough = pizzaIngredientFactory.CreateDough();

        sauce = pizzaIngredientFactory.CreateSauce();

        cheese = pizzaIngredientFactory.CreateCheese();

        veggies = pizzaIngredientFactory.CreateVeggies();

    }

}

/// <summary>

/// 香肠披萨

/// </summary>

public class PepperoniPizze : Pizza{

    PizzaIngredientFactory pizzaIngredientFactory;

    public PepperoniPizze(PizzaIngredientFactory pizzaIngredient){

        this.pizzaIngredientFactory = pizzaIngredient;

        this.SetName(" 香肠披萨  ");

    }

    public override void Prepare() {

        Debug.Log(" Prepare " + GetName());

        dough = pizzaIngredientFactory.CreateDough();

        sauce = pizzaIngredientFactory.CreateSauce();

        cheese = pizzaIngredientFactory.CreateCheese();

        veggies = pizzaIngredientFactory.CreateVeggies();

        pepperoni = pizzaIngredientFactory.CreatePepperoni();

    }

}

#region 披萨店

public enum PIZZETYPE {

    CHEESE,

    VEGGIE,

    CLAM,

    PEPPERONI

}

/// <summary>

/// Pizze store 抽象类

/// </summary>

public abstract class PizzeStore {

    public Pizza OrderPizza(PIZZETYPE type) {

        Pizza pizza;

        pizza = CreatrPizza(type);

        pizza.Prepare();

        pizza.Back();

        pizza.Cut();

        pizza.Box();

        return pizza;

    }

    /// <summary>

    /// 抽象的工厂方法  让子类负责定义自己的工厂方法

    /// </summary>

    /// <returns>The pizza.</returns>

    ///<param name="type">Type.

    public abstract Pizza CreatrPizza(PIZZETYPE type);

}

/// <summary>

/// 纽约风格的披萨店

/// </summary>

public class NYStylePizzeStore : PizzeStore {

    public PizzaIngredientFactory pizzaIngredientFactory;

    public NYStylePizzeStore() {

        pizzaIngredientFactory = new NYPizzaIngredientFactory();

    }

    public override Pizza CreatrPizza(PIZZETYPE type) {

        switch (type) {

            case PIZZETYPE.CHEESE:

                return new CheesePizze(pizzaIngredientFactory);

            case PIZZETYPE.VEGGIE:

                return new VeggiePizze(pizzaIngredientFactory);

            case PIZZETYPE.CLAM:

                return new ClamPizze(pizzaIngredientFactory);

            case PIZZETYPE.PEPPERONI:

                return new PepperoniPizze(pizzaIngredientFactory);

            default:

                return null;

        }

    }

}

/// <summary>

/// 纽约风格的披萨店

/// </summary>

public class ChicagoStylePizzeStore : PizzeStore {

    public PizzaIngredientFactory pizzaIngredientFactory;

    public ChicagoStylePizzeStore() {

        pizzaIngredientFactory = new ChicagoPizzaIngredientFactory();

    }

    public override Pizza CreatrPizza(PIZZETYPE type) {

        switch (type) {

            case PIZZETYPE.CHEESE:

                return new CheesePizze(pizzaIngredientFactory);

            case PIZZETYPE.VEGGIE:

                return new VeggiePizze(pizzaIngredientFactory);

            case PIZZETYPE.CLAM:

                return new ClamPizze(pizzaIngredientFactory);

            case PIZZETYPE.PEPPERONI:

                return new PepperoniPizze(pizzaIngredientFactory);

            default:

                return null;

        }

    }

}

#endregion

// ============== 各种原料 ============

/// <summary>

/// 面团

/// </summary>

public interface  Dough{

    void Dough();

}

public class NYDough : Dough{

    public void Dough(){

        Debug.Log("NYDough ");

    }

}

public class ChicagoDough : Dough {

    public void Dough() {

        Debug.Log("ChicagoDough ");

    }

}

/// <summary>

/// 果酱

/// </summary>

public interface Sauce{

    void Sauce();

}

public class NYSauce : Sauce {

    public void Sauce(){

        Debug.Log("NYSauce ");

    }

}

public class ChicagoSauce : Sauce {

    public void Sauce() {

        Debug.Log("ChicagoSauce ");

    }

}

/// <summary>

/// 奶酪

/// </summary>

public interface Cheese{

    void Cheese();

}

public class NYCheese : Cheese {

    public void Cheese() {

        Debug.Log("NYCheese ");

    }

}

public class ChicagoCheese : Cheese {

    public void Cheese() {

        Debug.Log("ChicagoCheese ");

    }

}

/// <summary>

/// 蔬菜

/// </summary>

public interface Veggies {

    void Veggies();

}

public class NYVeggies : Veggies {

    public void Veggies() {

        Debug.Log("NYVeggies ");

    }

}

public class ChicagoVeggies : Veggies {

    public void Veggies() {

        Debug.Log("ChicagoVeggies ");

    }

}

/// <summary>

/// 意大利香肠

/// </summary>

public interface Pepperoni {

    void Pepperoni();

}

public class NYPepperoni : Pepperoni {

    public void Pepperoni() {

        Debug.Log("NYPepperoni ");

    }

}

public class ChicagoPepperoni : Pepperoni {

    public void Pepperoni() {

        Debug.Log("ChicagoPepperoni ");

    }

}

/// <summary>

/// 蛤蜊 geli

/// </summary>

public interface Clams{

    void Clams();

}

public class NYClams : Clams {

    public void Clams() {

        Debug.Log("NYClams ");

    }

}

public class ChicagoClams : Clams {

    public void Clams() {

        Debug.Log("ChicagoSauce ");

    }

}

public class Garlic :Veggies{

    public void Veggies() {

        Debug.Log("Garlic ");

    }

}

public class Onion :Veggies {

    public void Veggies() {

        Debug.Log("Onion ");

    }

}

#endregion

本文由职坐标整理并发布，希望对同学们有所帮助。了解更多详情请关注职坐标编程语言C#.NET频道！