桥接模式 rust和java的实现

桥接模式

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

这种模式涉及到一个作为桥接的接口，使得实体类的功能独立于接口实现类，这两种类型的类可被结构化改变而互不影响。

桥接模式的目的是将抽象与实现分离，使它们可以独立地变化，该模式通过将一个对象的抽象部分与它的实现部分分离，使它们可以独立地改变。它通过组合的方式，而不是继承的方式，将抽象和实现的部分连接起来。

介绍

• 意图：将抽象部分与实现部分分离，使它们都可以独立的变化。
• 主要解决：在有多种可能会变化的情况下，用继承会造成类爆炸问题，扩展起来不灵活。
• 何时使用：实现系统可能有多个角度分类，每一种角度都可能变化。
• 如何解决：把这种多角度分类分离出来，让它们独立变化，减少它们之间耦合。

应用实例

1、猪八戒从天蓬元帅转世投胎到猪，转世投胎的机制将尘世划分为两个等级，即：灵魂和肉体，前者相当于抽象化，后者相当于实现化。生灵通过功能的委派，调用肉体对象的功能，使得生灵可以动态地选择。
2、墙上的开关，可以看到的开关是抽象的，不用管里面具体怎么实现的。

优点

1、抽象和实现的分离。
2、优秀的扩展能力。
3、实现细节对客户透明。

缺点

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

使用场景

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

关键角色

• 抽象（Abstraction）：定义抽象接口，通常包含对实现接口的引用。
• 扩展抽象（Refined Abstraction）：对抽象的扩展，可以是抽象类的子类或具体实现类。
• 实现（Implementor）：定义实现接口，提供基本操作的接口。
• 具体实现（Concrete Implementor）：实现实现接口的具体类。

实现

我们有一个作为桥接实现的 DrawAPI 接口和实现了 DrawAPI 接口的实体类 RedCircle、GreenCircle。Shape 是一个抽象类，将使用 DrawAPI 的对象。BridgePatternDemo 类使用 Shape 类来画出不同颜色的圆。
桥接模式的 UML 图

java

步骤 1
创建桥接实现接口。

DrawAPI.java

public interface DrawAPI {
   public void drawCircle(int radius, int x, int y);
}

步骤 2
创建实现了 DrawAPI 接口的实体桥接实现类。

RedCircle.java

public class RedCircle implements DrawAPI {
   @Override
   public void drawCircle(int radius, int x, int y) {
      System.out.println("Drawing Circle[ color: red, radius: "
         + radius +", x: " +x+", "+ y +"]");
   }
}

GreenCircle.java

public class GreenCircle implements DrawAPI {
   @Override
   public void drawCircle(int radius, int x, int y) {
      System.out.println("Drawing Circle[ color: green, radius: "
         + radius +", x: " +x+", "+ y +"]");
   }
}

步骤 3
使用 DrawAPI 接口创建抽象类 Shape。

Shape.java

public abstract class Shape {
   protected DrawAPI drawAPI;
   protected Shape(DrawAPI drawAPI){
      this.drawAPI = drawAPI;
   }
   public abstract void draw();  
}

步骤 4
创建实现了 Shape 抽象类的实体类。

Circle.java

public class Circle extends Shape {
   private int x, y, radius;
 
   public Circle(int x, int y, int radius, DrawAPI drawAPI) {
      super(drawAPI);
      this.x = x;  
      this.y = y;  
      this.radius = radius;
   }
 
   public void draw() {
      drawAPI.drawCircle(radius,x,y);
   }
}

步骤 5
使用 Shape 和 DrawAPI 类画出不同颜色的圆。

BridgePatternDemo.java

public class BridgePatternDemo {
   public static void main(String[] args) {
      Shape redCircle = new Circle(100,100, 10, new RedCircle());
      Shape greenCircle = new Circle(100,100, 10, new GreenCircle());
 
      redCircle.draw();
      greenCircle.draw();
   }
}

步骤 6
执行程序，输出结果：

Drawing Circle[ color: red, radius: 10, x: 100, 100]
Drawing Circle[  color: green, radius: 10, x: 100, 100]

rsut

// 画图的接口
trait DrawAPI {
    fn draw_circle(&self,radius:i32,x:i32, y:i32);      
}
// 画h
struct RedCircle {}
impl DrawAPI for RedCircle {
    fn draw_circle(&self,radius:i32,x:i32, y:i32) {
        println!("Drawing Circle[ color: red, radius: {}, x: {}, {}]",radius,x,y);
    }
}
struct GreenCircle {}
impl DrawAPI for GreenCircle  {
    fn draw_circle(&self,radius:i32,x:i32, y:i32) {
        println!("Drawing Circle[ color: green, radius: {}, x: {}, {}]",radius,x,y);
    }
}
trait Shape{
    fn draw(&self);
}
struct Circle{
    // // pub(crate) 使得函数只在当前 crate 中可见
    // 抽象方法的实现
    draw_api:Box,
    x:i32,
    y:i32,
    radius:i32
}
impl Circle {
    fn new(draw_api:Box,x:i32, y:i32, radius:i32)->Circle {
        Circle{
            draw_api,
            x,
            y,
            radius
        }
    }
}
impl Shape for Circle  {
    fn draw(&self) {
        self.draw_api.draw_circle(self.radius, self.x, self.y)
    }
}
fn main(){
    let r=Circle::new(Box::new(RedCircle{}),100,100, 10);
    let g=Circle::new(Box::new(GreenCircle{}),100,100, 10);
    r.draw();
    g.draw();

}

rust代码仓库

https://github.com/onenewcode/design.git
本教程项目在bin文件夹下的bridge.rs文件中