[设计模式、C++、go]结构型模式：桥接模式

桥接模式

介绍

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

桥梁模式(Bridge Pattern)也叫做桥接模式，是一个比较简单的模式，其定义如下: Decouple an abstraction from its implementation so that the two can varyindependently.(将抽象和实现解耦，使得两者可以独立地变化。)

意图： 将抽象部分与实现部分分离，使它们都可以独立的变化。

主要解决：
在有多种可能会变化的情况下，用继承会造成类爆炸问题，扩展起来不灵活。

何时使用：

实现系统可能有多个角度分类，每一种角度都可能变化。
对于两个独立变化的维度，使用桥接模式再适合不过了。

如何解决：

把这种多角度分类分离出来，让它们独立变化，减少它们之间耦合。

关键代码： 抽象类依赖实现类。

类图

Abstraction 抽象化角色:定义出该角色的行为，同时保存一个对实现化角色的引用，该角色一般是抽象类

Implementor: 实现化角色,他是接口或者抽象类，定义角色必须的行为和属性

RefinedAbstraction：修正抽象化角色，它引用实现化角色对抽象化角色进行修正。

Concretelmplementor：具体实现化角色，它实现接口或抽象类定义的方法和属性。

代码实现

我们现在的手机分为很多个品牌，而操作系统大致分为两种，Android和IOS,而这两种操作系统的游戏是不同的，但是如果我们都是用Android系统，无论是什么品牌的Android手机，都是可以使用相同的软件的，下面我们使用代码来模拟此过程。

C++

class PhoneSoft {
public:
	virtual void Run() = 0;
	virtual void Stop() = 0;
};

class PhoneAddressList :public PhoneSoft {
public:
	void Run() {
		cout << "phone address list start" << endl;
	}
	void Stop() {
		cout << "phone address list stop" << endl;
	}
};

class PhoneGame :public PhoneSoft {
public:
	void Run() {
		cout << "phone Game start" << endl;
	}
	void Stop() {
		cout << "phone Game stop" << endl;
	}
};


class Phone {

public:
	virtual void DownSoft(PhoneSoft* p) = 0;
	virtual void RunSoft() = 0;
	virtual void StopSoft() = 0;
};


class oppo :public Phone {
public:
	void DownSoft(PhoneSoft* p) {
		ps = p;
	}
	void RunSoft() {
		ps->Run();
	}
	void StopSoft() {
		ps->Stop();
	}
private:
	PhoneSoft* ps;
};


class vivo :public Phone {
public:
	void DownSoft(PhoneSoft* p) {
		ps = p;
	}
	void RunSoft() {
		ps->Run();
	}
	void StopSoft() {
		ps->Stop();
	}
private:
	PhoneSoft* ps;
};

测试

Phone* phone = new oppo;
    cout << "phone adress list download" << endl;
    PhoneAddressList pa;
    phone->DownSoft(&pa);
    phone->RunSoft();
    phone->StopSoft();

    cout << "phone game download" << endl;
    PhoneGame pg;
    phone->DownSoft(&pg);
    phone->RunSoft();
    phone->StopSoft();


    Phone* phone1 = new vivo;
    cout << "phone adress list download" << endl;
    PhoneAddressList pa1;
    phone1->DownSoft(&pa1);
    phone1->RunSoft();
    phone1->StopSoft();

Go

package Bridge

import (
	"fmt"
)

type PhoneSoft interface {
	Run()
	Stop()
}
type PhoneAdlist struct {
}

func (p *PhoneAdlist) Run() {
	fmt.Println("phone adress list start")
}
func (p *PhoneAdlist) Stop() {
	fmt.Println("phone adress list stop")
}

type PhoneGame struct{}

func (p *PhoneGame) Run() {
	fmt.Println("phone game start")
}
func (p *PhoneGame) Stop() {
	fmt.Println("phone game stop")
}

type Phone interface {
	DownloadSoft(p *PhoneSoft)
	RunSoft()
	StopSoft()
}

type Oppo struct {
	p PhoneSoft
}

func (ph *Oppo) DownloadSoft(p PhoneSoft) {
	ph.p = p
}
func (ph *Oppo) RunSoft() {
	ph.p.Run()
}

func (ph *Oppo) StopSoft() {
	ph.p.Stop()
}

type Vivo struct {
	p PhoneSoft
}

func (ph *Vivo) DownloadSoft(p PhoneSoft) {
	ph.p = p
}
func (ph *Vivo) RunSoft() {
	ph.p.Run()
}

func (ph *Vivo) StopSoft() {
	ph.p.Stop()
}

测试

phone := Bridge.Oppo{}
	fmt.Println("phone adress list download")
	phone.DownloadSoft(&Bridge.PhoneAdlist{})
	phone.RunSoft()
	phone.StopSoft()
	fmt.Println("phone game download")
	phone.DownloadSoft(&Bridge.PhoneGame{})
	phone.RunSoft()
	phone.StopSoft()

	phone1 := Bridge.Vivo{}
	fmt.Println("phone adress soft download")
	phone1.DownloadSoft(&Bridge.PhoneAdlist{})
	phone1.RunSoft()
	phone1.StopSoft()

phone adress list download
phone adress list start
phone adress list stop
phone game download
phone game start
phone game stop
phone adress soft download
phone adress list start
phone adress list stop

优缺点

优点：
1、抽象和实现的分离。

2、优秀的扩展能力。
只要对外暴露的接口允许，就可以扩展
3、实现细节对客户透明。
客户不用关心细节的实现，它已经由抽象层通过聚合关系完成了封装。

缺点：
桥接模式的引入会增加系统的理解与设计难度，由于聚合关联关系建立在抽象层，要求开发者针对抽象进行设计与编程。

使用场景：
1、如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的继承联系，通过桥接模式可以使它们在抽象层建立一个关联关系。
2、对于那些不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统，桥接模式尤为适用。
3、一个类存在两个独立变化的维度，且这两个维度都需要进行扩展。