Abstract Factory 抽象工厂模式(创建型模式)

 贴代码是为了方便以后查阅，没有想教人的想法，因为这代码是我看完 Abstract Factory模式后睡了一晚上第二天理解出来的。

如果有什么不对的地方还请指教，拜托了。

 

 

    /*先宏观的理解下面这句话后再看代码：
     *
     * 提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定它们具体的类。
             ——《设计模式》GoF
     */

    /************ 门，窗的抽象类 *************/
    public abstract class Door
    {
        public abstract void DoorStyle();//抽象方法，使派生类能够自由实现所需类型的门
    }

    public abstract class Window
    {
        public abstract void WindowStyle();//抽象方法，使派生类能够自由实现所需类型的窗
    }

    /************ 不同类型的门，窗的实现类 *************/
    public class WoodDoor : Door    //木门
    {
        public override void DoorStyle()
        {
            Console.WriteLine("使用木门");
        }
    }

    public class StoneDoor : Door   //石门
    {
        public override void DoorStyle()
        {
            Console.WriteLine("使用石门");
        }
    }

    public class WoodWindow : Window   //木窗
    {
        public override void WindowStyle()
        {
            Console.WriteLine("使用木窗");
        }
    }

    public class StoneWindow : Window  //石窗
    {
        public override void WindowStyle()
        {
            Console.WriteLine("使用石窗");
        }
    }

    /***************** 创建工厂 ********************/
    //这个工厂里面都是创建屋子需要的材料，在这个程序中是门和窗
    public abstract class AbstractFactory
    {
        public abstract Door GetDoor(); //抽象方法，使派生类能够自由实现所需类型的门
        public abstract Window GetWindow();//抽象方法，使派生类能够自由实现所需类型的窗
    }

    /******** 创建实现不同类型房屋的工厂 *********/
    public class BadHouseFactory:AbstractFactory  //生产坏屋的工厂
    {
        public override Door GetDoor()
        {
            return new WoodDoor();
        }

        public override Window GetWindow()
        {
            return new WoodWindow();
        }
    }

    public class GoodHouseFactory : AbstractFactory  //生产好屋的工厂
    {
        public override Door GetDoor()
        {
            return new StoneDoor();
        }

        public override Window GetWindow()
        {
            return new StoneWindow();
        }
    }

    /******** Client Application *********/
    public class ClientClass
    {
        //生产房屋所需要的对象（这个程序里假设只有门和窗）
        private Door door;      //门（没说明是木门还是石门）
        private Window window; //窗（没说明是木窗还是石窗）
      
        //是什么类型的门窗由传入的哪个工厂来决定
        public ClientClass(AbstractFactory af)
        {
            door = af.GetDoor();
            window = af.GetWindow();
        }
        public void MakeHouse()
        {
            door.DoorStyle();
            window.WindowStyle();
        }
        public static void Main()
        {
            Console.WriteLine("生产劣质房屋:");
            ClientClass t1 = new ClientClass(new BadHouseFactory());
            t1.MakeHouse();
            Console.WriteLine("/n----------------------/n");
            Console.WriteLine("生产优质房屋:");
            ClientClass t2 = new ClientClass(new GoodHouseFactory());
            t2.MakeHouse();
            Console.Read();
        }
    }

 

/* 代码说明：
 * 这个Demo的背景是一个建筑公司，这个建筑公司目前可以建筑两种类型的房屋（BadHouse and GoodHouse），在这里假设建筑房子只需要门和窗，
 * 也就是说建筑房屋需要的材料现在是恒定不变了，只有门和窗。
 * 那什么是变化的呢？比如说现在公司升级了，还可以建筑一般的混合房屋（NormalHouse）了（木门+石窗 or 石门+木窗），就是说建筑的房子的类型是变化的。
 *
 * 建筑房子所需要的材料：门，窗。（这个是恒定不变的）
 * 建筑房子的类型：BadHouse，GoodHouse，NormalHouse。（这个是变化的）
 *
 * 这时候就可以增加3个类来实现建筑NormalHouse了：NormalDoor（继承自Door），NormalWindow（继承自Window），NormalHouseFactory（继承自AbstractFactory），
 * 然后分别实现这3个类，现在建筑公司就可以建筑3种类型的房子了。
 *
 *
 * OK，再来理解一下这句话：
 * 提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定它们具体的类。
             ——《设计模式》GoF

 * 提供一个接口：
 *      在程序中是AbstractFactory类，当然可以把它写成接口，在这里我写成了类。
 *
 * 让该接口负责创建一系列“相关或者相互依赖的对象”：
 *      建筑房子需要什么？需要门和窗，门和窗就是依赖的的对象。不可能建筑一个房子只需要门而不需要窗。
 *
 * 无需指定它们具体的类：
 *      具体的类在这里指的是：WoodDoor，StoneDoor，WoodWindow和StoneWindow。在建筑房子的时候当然不需要指定这些具体的类了。
 *      为什么？因为有BadHouseFactory和GoodHouseFactory这两个工厂帮我们去和它们打交道了。
 *
 * 注意：门和窗是建筑房屋的恒定材料，如何改天建筑房子需要门，窗，砖了，过段时间又需要门，窗，砖，水泥了。如果是这样就不适合用
 * Abstract Factory模式了。
 *
*/