【设计模式】桥接模式

最新推荐文章于 2025-06-27 14:31:32 发布

原创最新推荐文章于 2025-06-27 14:31:32 发布 · 202 阅读

0 ·

CC 4.0 BY-SA版权

设计模式专栏收录该内容

3 篇文章

订阅专栏

本文探讨了如何使用桥接模式解决软件系统中多维度变化的问题，通过实例对比展示了如何避免类膨胀，并在游戏开发和图形绘制中应用此模式。桥接模式的优点在于提高系统可扩展性和降低复杂度，但设计时需要注意理解和识别变化维度。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

使用频率【3星】

一、概念

桥接（Bridge）是用于把抽象化与实现化解耦，使得二者可以独立变化。这种类型的设计模式属于结构型模式，它通过提供抽象化和实现化之间的桥接结构，来实现二者的解耦。

二、解决问题

在软件系统中，有些类型由于自身的逻辑，它具有两个或多个维度的变化。为了解决这种多维度变化，又不引入复杂度，就可以使用桥接模式。

三、对象

1、抽象类（Abstraction）：定义抽象接口，它一般是抽象类而不是接口。该接口中包含实现具体行为、具体特征的Implementor接口。

2、扩充的抽象类（RefinedAbstraction）：继承自Abstraction的子类，通常情况下它不再是抽象类而是具体类，它实现了在Abstraction中声明的抽象业务方法，在该对象中可以调用在Implementor中定义的业务方法。

3、实现类（Implementor）：定义具体行为，具体特征的应用接口。

4、具体实现类（ConcreteImplementor）：实现Implementor。

四、实现代码

1、未使用桥接模式。

一个游戏，主角身体里住着三个灵魂，它可以切换成对应的三种形态，来施放不同的技能。三种灵魂定义如下


public interface ISoul
{
	void CastSkill();
}
 
public class Mage : ISoul
{
	public void CastSkill()
	{
		Debug.Log ("Summon a box");
	}
}
 
public class Hunter : ISoul
{
	public void CastSkill()
	{
		Debug.Log ("Fire arrow");
	}
}
 
public class Warrior : ISoul
{
	public void CastSkill()
	{
		Debug.Log ("Power of Thor");
	}
}

但是身体只有一个，所以需要切换形态。貌似我们可以使用switch case语句来完成这个任务：【工厂方法模式】


public enum SoulType
{
	Mage,
	Hunter,
	Warrior,
}
public class Hero
{
	private Mage _mage = new Mage();
	private Hunter _hunter = new Hunter();
	private Warrior _warrior = new Warrior();
	private SoulType _soulType = SoulType.Mage;
	public void CastSkill()
	{
		ISoul activeSoul = null;
		switch (_soulType) {
		case SoulType.Mage:
			activeSoul = _mage;
			break;
		case SoulType.Hunter:
			activeSoul = _hunter;
			break;
		case SoulType.Warrior:
			activeSoul = _warrior;
			break;
		}
		activeSoul.CastSkill ();
	}
	public void ChangeSoul(SoulType soulType)
	{
		_soulType = soulType;
	}
}

//使用：
Hero hero = new Hero ();
		hero.ChangeSoul (SoulType.Hunter);
		hero.CastSkill ();

通过以上代码，我们会发现，再增加一个技能的形态，需要修改Hero的CasterSkill（），不符合开闭原则【可以拓展，但是尽量不修改原有的逻辑】。

2、桥接模式

接口和技能的形态类不修改，可以把Hero修改成以下的类

public class TrineHero
{
	private ISoul _soul;
	public void CastSkill()
	{
		_soul.CastSkill ();
	}
 
	public void ChangeSoul<T>() where T:ISoul, new()
	{
		_soul = new T();
	}
}
//使用修改成：
TrineHero th = new TrineHero ();
		th.ChangeSoul<Mage> ();
		th.CastSkill ();

增加一个新的技能形态，就可以新增一个技能的类

public class Priest : ISoul
{
	public void CastSkill()
	{
		Console.WriteLine ("Mind control");
	}
}

切换技能

//使用修改成：
TrineHero th = new TrineHero ();
th.ChangeSoul<Mage> ();
th.CastSkill ();
//切换不同技能
th.ChangeSoul<Priest> ();
th.CastSkill ();

总结：以上例子当中

抽象类/接口类（Abstraction）：TrineHero

扩充的抽象类（RefinedAbstraction）：Priest

实现类（Implementor）：ISoul

具体实现类（ConcreteImplementor）：Mage 三种技能

例子2

using System;
 
namespace ConsoleApp2
{
    class Class1
    {
        static void Main(string[] args)
        {
            //白色
            Color white = new White();
            //正方形
            Shape square = new Square();
            //白色的正方形
            square.SetColor(white);
            square.Draw();
 
            //长方形
            Shape rectange = new Rectangle();
            rectange.SetColor(white);
            rectange.Draw();
 
            Console.ReadLine();
        }
    }
 
    public abstract class Shape
    {
        public Color color;
        public void SetColor(Color color)
        {
            this.color = color;
        }
        public abstract void Draw();
    }
 
    public class Circle : Shape
    {
        public override void Draw()
        {
            color.Bepaint("正方形");
        }
    }
    public class Rectangle : Shape
    {
 
        public override void Draw()
        {
            color.Bepaint("长方形");
        }
    }
 
    public class Square : Shape
    {
        public override void Draw()
        {
            color.Bepaint("正方形");
        }
    }
 
    public interface Color
    {
        void Bepaint(string shape);
    }
 
    public class White : Color
    {
        public void Bepaint(string shape)
        {
            Console.WriteLine("白色的" + shape);
        }
    }
 
    public class Gray : Color
    {
        public void Bepaint(string shape)
        {
            Console.WriteLine("灰色的" + shape);
        }
    }
 
    public class Black : Color
    {
        public void Bepaint(string shape)
        {
            Console.WriteLine("黑色的" + shape);
        }
    }
}

总结：

抽象类/接口类（Abstraction）：Shape

扩充的抽象类（RefinedAbstraction）：Circle --继承shape

实现类（Implementor）：Color

具体实现类（ConcreteImplementor）：Black

说明：两个例子表示的两种桥接的使用情况，第一种是相同类型逻辑的扩展，第二种是两种不同逻辑的扩展

五、优缺点

　5.1 优点