设计模式(二十三)—桥梁模式
最后更新于：2022-04-01 16:26:41
**定义**:将抽象和实现解耦，使得两者之间可以独立的变化。
Abstract抽象化角色
---|主要职责是定义出该角色的行为，同时保存一个对实现化角色的引用。该角色一般是抽象类
Implementor实现化角色
---|他是接口或者抽象类，定义角色必须的行为和属性
RefinedAbstraction修正抽象化角色
---|它引用实现化角色对抽象化角色进行修正
ConcreteImplementor具体实现化角色
---|它实现接口或抽象类定义的方法和属性
------抽象角色引用实现角色，或者说抽象角色的部分实现是引用实现角色来完成的。
桥梁模式使用了类间的聚合关系、继承、覆写等常用功能
~~~
public class BridgeTest {
public static void main(String[] args) {
//定义一个实现化角色
Implementor imp = new ConcreteImplementor1();
//定义一个抽象化角色
Abstract abs = new RefinedAbstraction(imp);
abs.request();
}
}
/**
* 实现化角色
* 定义要实现的方法
* @author admin
*
*/
interface Implementor{
//基本方法
public void doSomething();
public void doAnything();
}
/**
* 具体实现化角色
* @author admin
*/
class ConcreteImplementor1 implements Implementor{
@Override
public void doSomething() {
System.out.println("具体实现化1，doSomething");
}
@Override
public void doAnything() {
System.out.println("具体实现化1，doAnything");
}
}
/**
* 具体实现化角色
* @author admin
*/
class ConcreteImplementor2 implements Implementor{
@Override
public void doSomething() {
System.out.println("具体实现化2，doSomething");
}
@Override
public void doAnything() {
System.out.println("具体实现化2，doAnything");
}
}
/**
* 抽象角色，定义该角色的行为，保存一个实现化角色的引用
* @author admin
*
*/
abstract class Abstract{
//定义对实现化角色的引用
private Implementor imp;
//约束子类必须去实现该构造函数
public Abstract(Implementor imp){
this.imp = imp;
}
//自身的行为和属性
public void request(){
this.imp.doSomething();
}
//得到实现化角色
public Implementor getImp(){
return this.imp;
}
}
/**
* 具体抽象化角色
* @author admin
*
*/
class RefinedAbstraction extends Abstract{
//覆写构造函数
public RefinedAbstraction(Implementor imp) {
super(imp);
}
//修正父类的行为
@Override
public void request() {
super.request();
super.getImp().doAnything();
}
}
~~~
## 一个例子:
一个商人，开了两家公司，一家专门做正规的产品，另一家做能挣钱的（不管正不正规）产品。
因此，当市场上那些可以盈利，他都会立马转型去做这个东西。但是公司内部人员不会改变。
如何解决公司在不用改变内部结构的前提下，实现公司的转型呢?这就需要一个桥梁来连接。
~~~
public class BridgeT {
public static void main(String[] args) {
//创建产品对象
House house = new House();
//创建出公司对象
Corp houseCorp = new HouseCorp(house);
houseCorp.makeMoney();
}
}
/**
* 抽象的公司类，
* 定义每个子公司需要实现的方法。
* 同时保存对实现化类的引用
* @author admin
*/
abstract class Corp{
private Product product;
//对实现化类的引用
public Corp(Product product) {
this.product = product;
}
//公司主要的目的是赚钱
public void makeMoney(){
//现生产商品
this.product.beProducted();
//再做销售
this.product.beSell();
}
}
/**
* 具体的公司实现类，实现对实现化类的引用
* @author admin
*
*/
class HouseCorp extends Corp{
public HouseCorp(Product product) {
super(product);
}
@Override
public void makeMoney() {
//不该变公司的策略
super.makeMoney();
System.out.println("房地产公司赚大钱了。。。");
}
}
/**
* 抽象类，具体子公司要实现的方法
* @author admin
*
*/
abstract class Product{
//产品销售
public abstract void beSell();
//产品生产
public abstract void beProducted();
}
/**
* 具体的产品实现类
* @author admin
*/
class House extends Product{
@Override
public void beSell() {
System.out.println("房子是这样卖出去的...");
}
@Override
public void beProducted() {
System.out.println("房子是这样生产的...");
}
}
~~~
**桥梁模式的优点:**
---|抽象和实现分离
---|优秀的扩充能力
---|实现细节对客户透明。
**桥梁模式的使用场景**
---|不希望或不适用使用继承的场景
---|接口或抽象类不稳定的场景
---|重用性要求较高的场景