3. Abstract Factory 抽象工厂（创建型模式)

new的问题
    常规的对象创建方法：
        // 创建一个Road 对象
        Road road=new Road();
    new的问题：
        – 实现依赖，不能应对“具体实例化类型”的变化。
解决思路：
    – 封装变化点—— 哪里变化，封装哪里
    – 潜台词：如果没有变化，当然不需要额外的封装！
工厂模式的缘起
    • 变化点在“对象创建”，因此就封装“对象创建”
    • 面向接口编程——依赖接口，而非依赖实现
简单工厂的问题：
    – 不能应对“不同系列对象”的变化。比如有不同风格的游戏场景——对应不同风格的道路、房屋、地道……
如何解决：
    – 使用面向对象的技术来“封装”变化点
动机（Motivation）
    在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时，由于需求的变化，往往存在更多系列对象的创建工作。
    如何应对这种变化？如何绕过常规的对象创建方法(new)，提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合？ 
    设计模式是解决一系列变化的问题，把变化的封装起来．
意图（Intent）
    提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定它们具体的类。
                                                                                                        ——《设计模式》GoF
结构（Structure）
        
    客户程序client依赖的是三个抽象类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    Abstract Product | 抽象产品#region Abstract Product | 抽象产品

    //Abstract Product
    public abstract class Road
    {
        public abstract void AAA();
    
    }

    public abstract class Building
    {
        public abstract void BBB();
    }

    public abstract class Tunnel
    {
        public abstract void CCC();
    }

    public abstract class Jungle
    {
        public abstract void DDD();
    }
    #endregion


    Mordern product | 现代的产品#region Mordern product | 现代的产品

    //Modern class
    public  class ModernRoad:Road
    {
        public override void AAA()
        {
            throw new NotImplementedException();
        }

    }

    public  class ModernBuilding:Building
    {
        public override void BBB()
        {
            throw new NotImplementedException();
        }

    }

    public  class ModernTunnel:Tunnel
    {
        public override void CCC()
        {
            throw new NotImplementedException();
        }

    }

    public  class ModernJungle:Jungle
    {
        public override void DDD()
        {
            throw new NotImplementedException();
        } 

    }

    #endregion


    Classicality product | 古代的产品#region Classicality product | 古代的产品

    //Classicality class
    public class ClassicalityRoad : Road
    {
        public override void AAA()
        {
            throw new NotImplementedException();
        }
    
    }
    public class ClassicalityBuilding : Building
    {
        public override void BBB()
        {
            throw new NotImplementedException();
        }
    }

    public class ClassicalityTunnel : Tunnel
    {
        public override void CCC()
        {
            throw new NotImplementedException();
        }
        
    }
    public class ClassicalityJungle : Jungle
    {
        public override void DDD()
        {
            throw new NotImplementedException();
        }
    }

    #endregion


    Abstract Factory | 抽象工厂：工厂方法模式的核心#region Abstract Factory | 抽象工厂：工厂方法模式的核心
    //Abstract Factory  (Abstract factory core)
    public abstract class FacilitiesFactory
    {
        public abstract Road CreateRoad();
        public abstract Building CreateBuilding();
        public abstract Tunnel CreateTunnel();
        public abstract Jungle CreateJungle();
    }
    #endregion


    Modern Factory | 现代工厂#region Modern Factory | 现代工厂

    //Modern Facotry（现代的工厂）
    public class MordenFacilitiesFactory : FacilitiesFactory
    {
        //override 重写
        public override Road CreateRoad()
        {
            return new ModernRoad(); //return morden product
        }

        public override Building CreateBuilding()
        {
            return new ModernBuilding();
        }

        public override Jungle CreateJungle()
        {
            return new ModernJungle();
        }

        public override Tunnel CreateTunnel()
        {
            return new ModernTunnel();
        }
    }
    #endregion


    Classicality | 古典工厂#region Classicality | 古典工厂

    public class ClassicalityFacilitiesFactory : FacilitiesFactory
    {
        //override 重写
        public override Road CreateRoad()
        {
            return new ModernRoad(); //return morden product
        }

        public override Building CreateBuilding()
        {
            return new ModernBuilding();
        }

        public override Jungle CreateJungle()
        {
            return new ModernJungle();
        }

        public override Tunnel CreateTunnel()
        {
            return new ModernTunnel();
        }
    }
    #endregion


    Client Application | 客户程序 (优点是保证客户端程序不变)#region Client Application | 客户程序 (优点是保证客户端程序不变)
    //Client Class
    class GameManager
    {
        FacilitiesFactory facilitiesFactory;
        Road road;
        Building building;
        Tunnel tunnel;
        Jungle jugle;
        public GameManager(FacilitiesFactory facilitiesFactory)
        {
            this.facilitiesFactory = facilitiesFactory;
        }

        public void BuildGameFacilities()
        {
             road = facilitiesFactory.CreateRoad();
             building = facilitiesFactory.CreateBuilding();
             tunnel = facilitiesFactory.CreateTunnel();
             jugle = facilitiesFactory.CreateJungle();
        }


        public void Run()
        {
            road.AAA();
            building.BBB();
            tunnel.CCC();
            jugle.DDD();

        }
    }
    #endregion

    class Program
    {
        static void Main(string[] args)
        {

            //调用现代工厂
            GameManager g = new GameManager(new MordenFacilitiesFactory());

            //调用古代工厂
            //GameManager g = new GameManager(new ClassicalityFacilitiesFactory());

     

            g.BuildGameFacilities();
            g.Run();
        }
    }
}

Abstract Factory模式的几个要点
    • 如果没有应对“多系列对象构建”的需求变化，则没有必要使用Abstract Factory模式，这时候使用简单的静态工厂完全可以。
    •“ 系列对象”指的是这些对象之间有相互依赖、或作用的关系，例如游戏开发场景中的“道路”与“房屋”的依赖，“道路”与“地道”的依赖。
    • Abstract Factory模式主要在于应对“新系列”的需求变动 。其缺点在于难以应对“新对象”的需求变动。
    • Abstract Factory模式经常和Factory Method模式共同组合来应对“对象创建”的需求变化。 
 

Q：Abstract 与 Interface 有什么分别

A：抽象类主要描述类型的类属关系，抽象类和它的派生类之间是典型的IS-A关系。而接口主要描述的是类型间的行为合同，接口和它的实现类之间是典型的CAN-DO关系。

________________________________________

Q：设计模式是不是现代软件开发的核心

A：不是，设计模式是一种高级的软件设计素养，它可以帮助我们写出更好的软件，具体到面向对象设计模式，它可以帮助我们应对频繁的软件需求变化。但设计模式本身并不构成现代软件开发的核心。