8、面向对象语言的23种设计模式-桥接模式

将对象中变化的部分进行封装，交给上端去选择使用。

就像面前有3座桥，每座桥去的地方都不一样，由你自己选择，大概就这么个意思。

作用就是解决多维度的变化，哪里变化就封装哪里。

当多个类实现同一个接口，每个类都有大量不同的版本的时候，通过桥接模式将变化的变化的部分进行封装，这样能大大减少子类数，能让上端自由选择需要的版本，大提升灵活性，但是对上端而言就需要了解更多的细节了。

看下图，当我们需要选择不同星球（M），不同种族（N），不同职业的角色（R）时，就需要创建多个子类（数量为M*N*R）

下面将使用桥接模式完成：

先看结果，如下图：

此时当需要增加不同的星球、种族或职业的时候，只需要增加对应的类就可以了。

主程序：

namespace Bridge
{
    class Program
    {
        static void Main(string[] args)
        {
            {
                RoleAbstract roleAbstract = new Role();
                roleAbstract.Star = new StarMars();
                roleAbstract.Race = new RaceTerran();
                roleAbstract.Occupation = new Fireman();
                roleAbstract.PrintMsg();
            }

            {
                RoleAbstract roleAbstract = new Role();
                roleAbstract.Star = new StarEarth();
                roleAbstract.Race = new RaceDwarves();
                roleAbstract.Occupation = new Engineer();
                roleAbstract.PrintMsg();
            }
        }
    }
}

角色类Role.cs：

namespace Bridge
{
    public class Role : RoleAbstract
    {
        //public override string Occupation()
        //{
        //    return "工程师";
        //}

        //public override string Race()
        //{
        //    return "人族";
        //}

        //public override string Star()
        //{
        //    return "地球";
        //}

        public override void PrintMsg()
        {
            Console.WriteLine("星球：" + Star.Star() + ",种族：" + Race.Race() + ",职业：" + Occupation.Occupation());
        }

    }
}

抽象类RoleAbstract.cs：

namespace Bridge.RoleDetails
{
    public abstract class RoleAbstract
    {
        /// 

        /// 星球
        /// 
        //public abstract string Star();
        public IStar Star { get; set; }

        /// 

        /// 种族
        /// 
        //public abstract string Race();
        public IRace Race { get; set; }

        /// 

        /// 职业
        /// 
        //public abstract string Occupation();
        public IOccupation Occupation { get; set; }


        public abstract void PrintMsg();
    }
}

接口：

//IStar.cs
namespace Bridge.RoleDetails
{
    public interface IStar
    {
        string Star();
    }
}

//IRace.cs
namespace Bridge.RoleDetails
{
    public interface IRace
    {
        string Race();
    }
}

//IOccupation.cs
namespace Bridge.RoleDetails
{
    public interface IOccupation
    {
        string Occupation();
    }
}

星球：

//StarEarth.cs
namespace Bridge.RoleDetails.Stars
{
    public class StarEarth : IStar
    {
        public string Star()
        {
            return "地球";
        }
    }
}

//StarMars.cs
namespace Bridge.RoleDetails.Stars
{
    public class StarMars : IStar
    {
        public string Star()
        {
            return "火星";
        }
    }
}

种族：

//RaceDwarves.cs
namespace Bridge.RoleDetails.Races
{
    public class RaceDwarves : IRace
    {
        public string Race()
        {
            return "矮人族";
        }
    }
}

//RaceTerran.cs
namespace Bridge.RoleDetails.Races
{
    public class RaceTerran : IRace
    {
        public string Race()
        {
            return "人族";
        }
    }
}

职业：

//Engineer.cs
namespace Bridge.RoleDetails.Occupation
{
    public class Engineer : IOccupation
    {
        public string Occupation()
        {
            return "工程师";
        }
    }
}

//Fireman.cs
namespace Bridge.RoleDetails.Occupation
{
    public class Fireman : IOccupation
    {
        public string Occupation()
        {
            return "消防员";
        }
    }
}

虽然在使用的时候更加的灵活，而且也不需要哪么多的子类，但是特别的复杂，上端也需要知道更多的细节才能使用，每种设计模式都有自己适用的场景，在适合的地方使用就可以了。

以上是本章的所有内容，谢谢观看，有帮助的麻烦点点赞，哈哈。

完。