04 抽象工厂模式(创建性模式)

抽象工厂模式(创建性模式)


1> new 的问题

  • 常规的对象创建方法:
//创建一个Road对象
Road road=new Road();
  • new的问题:实现依赖,不能应对“具体实例化类型的变化。
  • 解决思路:封装变化点一哪里变化,封装哪里。潜台词:如果没有变化,当然不需要额外的封装。

2> 工厂模式的缘起

  • 变化点在“对象创建”,因此就封装“对象创建”
  • 面向接口编程——依赖接口,而非依赖实现
  • 最简单的解决方法:
  class RoadF actory 
  {
      public static Road CreateRoad()
      {
          retum new Road0; 
      }
  }
 //--------------------------------------------------
//创建一一个Road对象,客户程序
  Road road = roadFactory.CreateRoad();

2.1 创建一系列相互依赖的对象

  • 假设一个游戏开发场景: 我们需要构造"道路"、“房屋”、“地道”、“丛林”等等对象。
Road road = roadFactory.CreateRoadl();
Building building = roadFactory.CreateBuilding();
-------------------------------------------------------------
 class RoadFactory
        {
            public static Road CreateRoad()
            {
                retum new Road();
            }
            public static Building CreateBuilding()
            {
                retum new Building()
            }
            public static Tunnel CreateTunnel()
            {
                retum new Tunnel()
            }
            public static Jungle CreateJungle()
            {
                retum new Jungle();
            }
        }

2.2 简单工厂的问题

  • 不能应对“不同系列对象”的变化。比如有不同风格的游戏场景——对应不同风格的道路、房屋、地道

  • 如何解决——使用面向对象的技术来“封装”变化点。


2.3 动机

  • 在软件系统中,经常面临着一系列相互依赖的对象的创建工作;同时,由于需求的变化,往往存在更多系列对象的创建工作。

  • 如何应对这种变化?如何绕过常规的对象创建方法(new),提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合?


2.4 意图

  • 提供一个接口,让该接口负责创建一系列“相关或者相互依赖的对象”,无需指定它们具体的类。

2.5 抽象工厂模式结构

04 抽象工厂模式(创建性模式)


3> 一个简单的工厂模式运用

    public abstract class Road
    {
       public abstract void FuncRoad();
    }
    //房屋
    public abstract class Building
    {
        public abstract void FunBuilding();
    }
    //地道
    public abstract class Tunnel
    {
        public abstract void FuncTunnel();
    }
    //丛林
    public abstract class Jungle
    {
        public abstract void FuncJungle();
    }
    abstract class FacilitiesFactory//抽象的工厂
    {
        public abstract Road CreateRoad();
        public abstract Building CreateBuilding();
        public abstract Tunnel CreateTunnel();
        public abstract Jungle CreateJungle();
    }
  • 客户程序只通过一个抽象工厂创造各建造类型的访问,不用每一个单独new创建。
    class GameManager//客户程序 只依赖抽象工厂而不是各种抽象类
    {
        FacilitiesFactory facilitiesFactory;
        Road road;
        Building building;
        Tunnel tunnel;
        Jungle jungle;
        public GameManager(FacilitiesFactory facilitiesFactory)
        {
            this.facilitiesFactory = facilitiesFactory;//创建工厂对象
        }
        public void BuildGameFacilities()//执行工厂生产行为
        {
            road = facilitiesFactory.CreateRoad();
            building = facilitiesFactory.CreateBuilding();
            tunnel = facilitiesFactory.CreateTunnel();
            jungle = facilitiesFactory.CreateJungle();
        }
        public void Run()//执行产品功能
        {
            road.FuncRoad();
            building.FunBuilding();
            tunnel.FuncTunnel();
            jungle.FuncJungle();
        }
    }

4> 工厂模式简单拓展

    //道路
    public abstract class Road
    {
       public abstract void FuncRoad();
    }
    //房屋
    public abstract class Building
    {
        public abstract void FunBuilding();
    }
    //地道
    public abstract class Tunnel
    {
        public abstract void FuncTunnel();
    }
    //丛林
    public abstract class Jungle
    {
        public abstract void FuncJungle();
    }
    abstract class FacilitiesFactory//抽象的工厂
    {
        public abstract Road CreateRoad();
        public abstract Building CreateBuilding();
        public abstract Tunnel CreateTunnel();
        public abstract Jungle CreateJungle();
    }//抽象工厂搭建,作为基础抽象类用来拓展不同的版本,实现多态和封装
//-------------------------------------------------------------
    //具体工厂实现————生产一*代风格的对象
    public class ModernRoad : Road//继承Road创建现代风格的道路
    {
        public override void FuncRoad() { }
    }
    //房屋
    public class ModernBuilding : Building//继承Building创建现代风格的房屋
    {
        public override void FunBuilding() { }
    }
    //地道
    public class ModernTunnel : Tunnel//继承Tunnel创建现代风格的地道
    {
        public override void FuncTunnel() { }
    }
    //丛林
    public class ModernJungle : Jungle//继承Jungle创建现代风格的丛林
    {
        public override void FuncJungle() { }
    }
    class ModernFacilitiesFactory : FacilitiesFactory
    {
        public override Road CreateRoad()
        {
            return new ModernRoad();
        }
        public override Building CreateBuilding()
        {
            return new ModernBuilding();
        }
        public override Tunnel CreateTunnel()
        {
            return new ModernTunnel();
        }
        public override Jungle CreateJungle()
        {
            return new ModernJungle();
        }
    }
//----------------------------------------------------------
//客户程序不需要一直变化,只需要将不同的工厂类型传入即可,保证了客户程序的稳定性   
     class GameManager
    {
        FacilitiesFactory facilitiesFactory;
        Road road;
        Building building;
        Tunnel tunnel;
        Jungle jungle;
        public GameManager(FacilitiesFactory facilitiesFactory)
        {
            this.facilitiesFactory = facilitiesFactory;
        }
        public void BuildGameFacilities()
        {
            road = facilitiesFactory.CreateRoad();
            building = facilitiesFactory.CreateBuilding();
            tunnel = facilitiesFactory.CreateTunnel();
            jungle = facilitiesFactory.CreateJungle();
        }
        public void Run()
        {
            road.FuncRoad();
            building.FunBuilding();
            tunnel.FuncTunnel();
            jungle.FuncJungle();
        }
    }

5> 工厂模式调用模拟

class test{
    static void Main(string[] args)
   {
      GameManager gm = new GameManager(ModernFacilitiesFactory);
      //创建一个现代风格的场景。
   }
}

6> Abstract Factory模式的几个要点

  • 如果没有应对“多系列对象构建”的需求变化,则没有必要使用Abstract Factory模式,这时候使用简单的静态工厂完全可以。

    即直接在类中实现工厂,而不需要再创建抽象工厂应对不同的变化。多新系列的变化会使用抽象工厂模式。

  • “系列对象”指的是这些对象之间有相互依赖、或作用的关系,例如游戏开发场景中的“道路”与"房屋”的依赖,“道路”与“地道”的依赖。

  • Abstract Factory模式主要在于应对“新系列”的需求变动。其缺点在于难以应对“新对象”的需求变动。

  • Abstract Factory模式经常和Factory Method模式共同组合来应对“对象创建”的需求变化。


上一篇:创建型设计模型 - 抽象工厂


下一篇:java 中 抽象类