设计模式——创建型模式之 Abstract Factory抽象工厂模式

我们客户程序中最有可能碰到的事情之一就是new一个对象: Road road = new Road();
当客户程序不是很复杂,变化不多的时候是没什么问题的,可是一旦有了变化,很多问题就随之而来了.
Class Customer{
Road road = new Road();
...........
}
现在假设我想将road改成wateroad,试想一下，客户程序中期不是要改很多东西，必须实现封装。一个最简单的封装是：
class RoadFactory{
public static Road CreateRoad(){
return new Roadl;}}

客户程序中：Road road=RoadFactory.createRoad();
这样就实现了最简单的封装，可是这样却不能应对“一系列相互依赖的对象”的创建工作，实际上的抽象工厂如图：

..........这个破csdn，nnd上传个图片都上传不了，搞了n久还是不行
今天心情很烦躁，直接代码示之：

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

namespace  cSharp_AbstractFactory_test
... {
    abstract class Road 
    ...{ }
    abstract class Jungle 
    ...{ }
    abstract class Tunle 
    ...{ }

    abstract class Factory 
    ...{
        public abstract Road createRoad();
        public abstract Jungle createJungle();
        public abstract Tunle createTuble();

    }

    class OldRoad : Road ...{ }
    class OldJungle : Jungle ...{ }
    class OldTunle : Tunle ...{ }

    class ModernRoad : Road ...{ }
    class ModernJungle : Jungle ...{ }
    class ModernTunle : Tunle ...{ }

    class OldFactory : Factory
    ...{
        public override Road createRoad()
        ...{
            return new OldRoad();
        }
        public override Jungle createJungle()
        ...{
            return new OldJungle();
        }
        public override Tunle createTuble()
        ...{
            return new OldTunle();
        }
    }

    class ModernFactory : Factory 
    ...{
        public override Road createRoad()
        ...{
            return new ModernRoad();
        }
        public override Jungle createJungle()
        ...{
            return new ModernJungle();
        }
        public override Tunle createTuble()
        ...{
            return new ModernTunle();
        }
    }


    class GameManager 
    ...{
        private Factory factory;
        Road road;
        Jungle jungle;
        Tunle tunle;
        public GameManager(Factory factory)
        ...{
            this.factory = factory;
        }
        public void buildGameFactory
        ...{
               road = factory.createRoad();
               jungle = factory.createJungle();
               tunle = factory.createTunle();
        }
        public void run 
        ...{
            //........
        }
    }

    class Program
    ...{
        static void Main(string[] args)
        ...{
            GameManager g = new GameManager(new ModernFactory()); // or OldFactory
            g.buildGameFactory();
            g.run();
            
            
        }
    }
}