设计模式之Abstract Factory的学习笔记

设计模式之Abstract Factory的学习笔记

1、创建型的模式我们说他主要解决的就是一个new的问题，我们
知道，我们通常创建对都是用的new XX()这种方式。

  例：//在一个游戏场景中要创建一个道路Road对象
     
    Road road=new Road();

 但是new 在我们解决一些问题的时候，它本身不能满足我们需求的变化。

  很明显的一个问题就是 new 实现依赖（依赖于类的具体实现），
它不能应对“具体实例化类型”的变化。

   什么意思呢？
      比如说那上面的列子来说，在游戏场景中，我们的道路有可能会
场景的需要进行变化，比如我要换一个水泥路，我要换一个木质的路，
这种个种各样的变化它就不能应对这种变化。

 2、 解决思路：
    ---封装变化点 ：哪里变化，封装哪里。（面向对象的核心）
    ---潜台词:如果没有变化，当然不需要额外的封装。

 好的面向对象所追寻的原则 变化点在“对象创建”，因此就封装“对象创建”

  面向接口编程------依赖接口，而非依赖实现。

   最简单的解决方法：
  
       //封装路的创建方式。
    class RoadFactory
     {
        public static Road CreateRoad()
         {
           //变化点进行封装。面对新的需求我们只在这里改就行了。
           return new Road();//return new WaterRoad()--一个泥淋的路
         }
     }

===========================================================
       //客户程序(使用这个路)
       Road road=
             RoadFactory.CreateRoad();

 3、上面的代码只是一个简单的封装。下面进行延深
 
   假设一个游戏开发场景：我们需要构造“道路”，“房屋”，“地道”,
 “丛林”，......等等对象。

  Road road=roadFactory.CreateRoad();
 .............  这一块的代码又相对稳定了。
  Building building=roadFactory.CreateBuildng();

 ===============
      class RoadFractory
       {
          //建立道路
         public static Road CreateRoad()
          {
            return new Road();
          }
           //建立房屋
         public static Bluilding CreateBluilding()
           {
            return new Building();
           }
           //建立地道
         public static Tunnel CreateTunnel()
          {
              return new Tunnel();
          }

          //建立丛林
          public static Jungle CreateJungle()
           {
               return new Jungle();
           }
        }
      
   一系列相互依赖的对象。比如说地道从屋子里通道丛林中。它们之间就存在着
相互依赖的对象。

 4、简单工厂的问题：
   
    上面的代码又出现问题了，比如说房屋，道路....又要变成不同风格的房屋，道路，
那么上面静态方法创建的房屋道路等等对象又成了变化点了。

  如果一个系列上面的静态工厂就可以解决了。多个系列静态工厂就不能满足需求。

  如何解决呢？
    这才引出来我们今天要学习的，使用面向对象的技术来“封装变化点”
  
    动机（Motivation）
         在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同
时，由于需求的变化，往往存在更多系列的对象的创建工作。

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

5、抽象工厂

        //路
        public abstract class Road
        { 
            public abstract void AAA()
               {..........}
         }
 //房屋
  public abstract class Buliding
        {
           
         }

 //地道
  public abstract class Tunnel
        {
           
         }

 //丛林
  public abstract class JSSungle
        {
           
         }
abstract class FacilitiesFractory
{
 public abstract Road CreateRoad();
        public abstract Buliding CreateBuliding();
        public abstract Tunnel CreateTunnel();
        public abstract Jungle CreateJungle();
}

//客户的代码 最大的依赖抽象类 不依赖实现
class GameManager
{
      //这个类相对稳定
        FacilitiesFractory facilitiesFractory；
          Road road;
           Buliding buliding;
           Tunnel tunnel;
           Jungle jungle;
 public GameManager(FacilitiesFractory facilitiesFractory)
        {
           this.facilitiesFractory=FacilitiesFractory; 
         }

        public void BulidGameFacilities()
        {
           road=facilitiesFractory.CreateRoad();
           buliding=facilitiesFractory.CreateBuliding();
           tunnel=facilitiesFractory.CreateTunnel();
           jungle=facilitiesFractory.CreateJungle();
        
         }
          
         public void run()
          {
            road.AAA();
            buliding.BBB(road);
            tunnel.CCC();
            jungle.DDD(tunnel);
          }
 
}

//各个对象的具体类
   //路
        public class ModernRoad:Road
        {
           
         }
 //房屋
  public class ModernBuliding:Buliding
        {
           
         }

 //地道
  public class ModernTunnel:TunnelSS
        {
           
         }

 //丛林
  public class Modernjungle:Jungle
        {
           
         }

//具体实现
public class ModernFacilitiesFractory:FacilitiesFractory
{
 public override Road CreateRoad(){return new ModrenRoad();}
        public override  Buliding CreateBuliding(){return new ModrenBuliding()}
        public override  Tunnel CreateTunnel(){return new ModrenTunnle();}
        public override  Jungle CreateJungle(){return new ModrenJungle();}
}

 

//主调类
class App
{
 public static void Main()
        {
             
           GameManager g=new GamManage(new ModernFacilitiesFractory());
           g.BulidGameFaclities();
           g.run();
          }
}

6、要点
     如果没有多个系列对象构建的需求变化，则没有必要使用Abstract Factroy,
使用简单的静态工厂完全可以。

    系列对象指的是这些对象之间有相互依赖，或作用的关系。
    Abstract factory 模式主要在于应对新系列的需求变动。其缺点在于难以对新
对象的需求变动。
 
     Abstract factory模式经常和Factory Mothod 模式共同组合来应对“对象创建”
的需求变化。