设计模式

抽象工厂模式(AbstractFactory)

创建型设计模式。为创建一组相关或相互依赖的对象提供一个接口，而且无需指定它们的具体类。

工厂模式

  • 创建一个人

    1
    Person p = new Person();

  • 创建一个男人

    1
    Person p = new Man();

  • 创建一个女人

    1
    Person p = new Woman();

  • 封装变化点

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    Person p = PersonFactory.GetPerson();
    public class PersonFactory
    {
        public static Person GetPerson()
        {
            //需要什么实例，修改并返回所需实例
            //reutrn new Person();
            //return new Man();
            return new Woman();
        }
    }

工厂模式创建一系列相互依赖的对象

  • 调用

    1
    2
    3
    4
    5
    6
    //路
    Road r = SkinFactory.GetRoad();
    //建筑物
    Building b = SkinFactory.GetBuilding();
    //丛林
    Jungle j = SkinFactory.Jungle();

  • 定义

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    public class SkinFactory()
    {
        public static Road GetRoad()
        {
            //水泥路
            return new WaterRoad();
            //高速公路
            //return new Highway();
        }
        
        public static Building GetBuilding()
        {
            //居民楼
            return new ResidentBuilding();
            //办公楼
            //return new OfficeBuilding();   
        }
        
        public static Jungle GetJungle()
        {
            //绿色丛林
            return new GreenJungle();
            //黄色森林(荒野)
            //return new YellowJungle();
        }
    }

抽象工厂

一个游戏，需要经常变换游戏场景，比如，第一个月是经典场景，第二月换为现代场景…如此看来，场景是变化点，需要对场景进行封装。也就是对上一个例子的SkinFactory进行抽象封装。(设计很大部分都是为了扩展，而非修改)

  • 场景抽象类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    public abstract class Road{}
    public abstract class Building{}
    public abstract class Jungle{}
    public abstract class SkinFactory
    {
        public abstract Road GetRoad();
        public abstract Building GetBuilding();
        public abstract Jungle GetJungle();
    }

  • 经典场景实现类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    public class WaterRoad:Road{}
    public class ResidentBuilding:Building{}
    public class GreenJungle:Jungle{}
    public class ClassicSkinFactory:SkinFactory
    {
        public override Road GetRoad()
        {
            return new WaterRoad();
        }
        public override Building GetBuilding()
        {
            return new ResidentBuilding();
        }
        public override Jungle GetJungle()
        {
            return new GreenJungle();
        }
    }

  • 现代场景实现类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    public class Highway:Road{}
    public class OfficeBuilding:Building{}
    public class YellowJungle:Jungle{}
    public class ModernSkinFactory:SkinFactory
    {
        public override Road GetRoad()
        {
            return new Highway();
        }
        public override Building GetBuilding()
        {
            return new OfficeBuilding();
        }
        public overide Jungle GetJungle()
        {
            return new YellowJungle();
        }
    }

  • 客户端调用

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    void Main()
    {
        //实例化SkinFactory
        SkinFactory skinFactory = new ClassicSkinFactory();
        //实际调用ClassicSkinFactory.GetRoad()
        Road r = skinFactory.GetRoad();
        
        Building b = skinFactory.GetBuilding();
        Jungle j = skinFactory.GetJungle();
    }