3、Abstract Factory抽象工厂（创建型模式）

new的问题

常规的对象创建方法：

​ //创建一个Road对象

​ Road road=new Road();

new的问题：

实现依赖，不能应对“具体实例化类型”的变化。

解决问题：

• 封装变化点——那里变化，封装哪里
• 潜台词:如果没有变化，当然不需要额外的封装！

工厂模式的缘起

• 变化点在“对象创建”，因此就封装“对象创建”。

• 面向接口编程——以来接口，而非以来实现。

• 最简单的解决方法：

  class RoadFactory{

  ​ public static Road CreatRoad(){

  ​ return Road();

  ​ }

  }

  //创建一个Road对象

  Road road=roadFactory.CreateRoad();

简单工厂的问题

不能应对“不同系列对象”的变化。

如何解决

使用面向对象的技术来“封装”变化点

动机

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

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

意图

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

结构

客户程序不依赖于具体实现，只依赖于三个抽象的类。

//道路
public abstract class Road {
}
//房屋
public abstract class Buliding {
}
//地道
public abstract class Tunnel {
}
//丛林
public abstract class Jungle {
}
abstract class FacilityFactory{

    public abstract Road CreatRoad();
    public abstract Buliding CreateBuliding();
    public abstract Tunnel CreateTunnel();
    public abstract Jungle CreateJungle();
}
//客户程序
class GameManager{
    Road road;
    Buliding buliding;
    Tunnel tunnel;
    Jungle jungle;

    FacilityFactory facilityFactory;
    public GameManager(FacilityFactory facilityFactory){
        this.facilityFactory=facilityFactory;
    }
    public void BulidGameFacilities(){
        road=facilityFactory.CreatRoad();
        buliding=facilityFactory.CreateBuliding();
        tunnel=facilityFactory.CreateTunnel();
        jungle=facilityFactory.CreateJungle();
    }
    public void play(){
        road.AAA();
        buliding.BBB(road);
        tunnel.CCC();
        jungle.DDD(tunnel);

    }
}
//现代风格
//道路
public class MordenRoad:Road {
}
//房屋
public class MordenBuliding:Buliding {
}
//地道
public class MordenTunnel:Tunnel {
}
//丛林
public class MordenJungle:Jungle {
}
abstract class MordenFacilityFactory:FacilityFactory{

    public override Road CreatRoad(){
          return new MordenRoad();
        }
    public override Buliding CreateBuliding(){
          return new MordenBuliding();
        }
    public override Tunnel CreateTunnel(){
           return new MordenTunnel();
        }
    public override Jungle CreateJungle(){
           return new MordenJunngle();
        }
}
class App{
    public static void main(String[] args) {
        GameManager g=new GameManager(new MordenFacilityFactory());

        g.BulidGameFacilities();
        g.Run();
    }
}

Abstract Factory模式的几个要点

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