abstract factoy模式

/*解决问题：实现依赖，不能应对“具体实例类型”的变化。

     * 因此，我们要封装变化点。

     * 如：我们需要创建地道、房屋、丛林等一系列对象，然而，需求是要重建不同系列的对象。

     * 为此，提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合。

     *

     * 意图：提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定他们具体的类。

     */

 

    //road的继承关系，包括两种类型的道路

    public abstract class road

    {

        public abstract road createRoad();

    }

 

    class road1:road

    {

        public override road createRoad()

        {

            System.Console.WriteLine("road1");

            return new road1();

        }

    }

    class road2 : road

    {

        public override road createRoad()

        {

            System.Console.WriteLine("road2");

            return new road2();

        }

    }

 

    //building的继承关系，包括两种类型的房屋

    public abstract class buliding

    {

        public abstract buliding createBuilding();

    }

    class building1 : buliding

    {

        public override buliding createBuilding()

        {

            System.Console.WriteLine("building1");

            return new building1();

        }

    }

    class building2 : buliding

    {

        public override buliding createBuilding()

        {

            System.Console.WriteLine("building2");

            return new building2();

        }

    }

 

 

    //抽象工厂类

    public abstract class AbstractFactory

    {

        public abstract road createRoad();

        public abstract buliding createBuliding();

    }

 

    //两个具体工厂，都实现了抽象工厂定义的方法，分别对应一个系列的房屋和道路

    public class ConcreateFactory1:AbstractFactory

    {

        public override road createRoad()

        {

            road1 rd1 = new road1();

            return rd1.createRoad();

           

        }

        public override buliding createBuliding()

        {

            building1 bd1 = new building1();

            return bd1.createBuilding();

        }

    }

 

    public class ConcreateFactory2 : AbstractFactory

    {

        public override road createRoad()

        {

            road2 rd2 = new road2();

            return rd2.createRoad();

 

        }

        public override buliding createBuliding()

        {

            building2 bd2 = new building2();

            return bd2.createBuilding();

        }

    }

 

    //客户程序对抽象工厂的调用

    class client

    {

        private AbstractFactory factory;//保存抽象工厂的引用

        public client(AbstractFactory factory)

        {

            this.factory = factory;

        }

 

        public void createFacility()

        {

            buliding bd = factory.createBuliding();

            road rd = factory.createRoad();

            /*

             * 以下为对创建系列的对象进行业务规则的处理

             *

             */

 

        }

 

        /*

         * 如果没有多个系列的对象需要创建[即多个系列的道路和房屋]，则没有必要使用抽象工厂。

         * 变化的轴心在多个系列，才能使用。假设需求变化的在于增加丛林、海洋等等场景，则不适合使用该模式。

         * 即是应对“新系列”的需求，而不是“新对象”的需求。

         *

         * 系列的对象：是指相互依赖、相互关联的多种类型对象。

         *

         * 抽象工厂模式经常和工厂方法模式组合，应对“对象创建”的变化。

         */

 

        //程序入口

        static void main(string[] args)

        {

            ConcreateFactory 1 f 1 = new ConcreateFactory1();

            ConcreateFactory 2 f 2 = new ConcreateFactory2();

 

            client clt1 = new client(f1);

            clt1.createFacility();

            //输出：building1 road1

 

            client clt2 = new client(f2);

            clt2.createFacility();

            //输出：building2 road2

 

            System.Console.WriteLine("end");

        }

    }