桥接模式

桥接模式

定义

将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度

应用场景

使用场景，一个类中存在多个对象之间存在相互的引用关系，且这多个类都需要扩展
比如我有三个形状 长方形 正方形 圆形，三种颜色 白色 黑色 红色,然后需要根据这几个进行组合成比如黑色的长方形，红色的圆形等等，而且后续还需要扩展形状以及颜色
，那么这种组合关系就会有很多

优点

1.降低耦合度
2.有良好的扩展性

缺点

增加了系统理解的复杂程度，由于关系的建立是在抽象层，因此要进行抽象的设计以及编程

实现

需求 ：有三个形状 长方形 正方形 圆形，三种颜色 白色 黑色 红色,然后需要根据这几个进行组合成比如黑色的长方形，红色的圆形等等

1 简单实现方式

直接实现，不考虑任何其他的场景

颜色类

黑色

public class Black {

    public String returnBlackColor() {
        return "black";
    }
}

红色

public class Red {

    public String returnRedColor() {
        return "red";
    }
}

白色

public class White {

    public String returnWhiteColor() {
        return "white";
    }
}

形状类

圆形

public class Circle {


   public void getRedCircle(Red red) {
      System.out.println(red.returnRedColor() + " circle");
   }

   public void getBlackCircle(Black black) {
      System.out.println(black.returnBlackColor() + " circle");
   }

   public void getWhiteCircle(White white) {
      System.out.println(white.returnWhiteColor() + " circle");
   }
}

长方形

public class Rectangle {

    public void getRedRectangle( Red red) {
        System.out.println(red.returnRedColor() + " rectangle");
    }

    public void getBlackRectangle(Black black) {
        System.out.println(black.returnBlackColor() + " rectangle");
    }

    public void getWhiteRectangle(White white) {
        System.out.println(white.returnWhiteColor() + " rectangle");
    }
}

正方形

public class Square {

    public void getRedSquare(Red red) {
        System.out.println(red.returnRedColor() + " square");
    }

    public void getBlackSquare(Black black) {
        System.out.println(black.returnBlackColor() + " square");

    }

    public void getWhiteSquare(White white) {
        System.out.println(white.returnWhiteColor() + " square");
    }
}

测试类

 public static void main(String[] args) {
        //获取红色的长方形
        Rectangle rectangle = new Rectangle();
        rectangle.getRedRectangle(new Red());

        //获取白色的圆
        Circle circle = new Circle();
        circle.getWhiteCircle(new White());
    }

这种方式会有下面的缺点
增加一种类型的颜色或者形状，需要增加很多方法，各自都需要增加内容以及方法，而且耦合度很强

2 优化实现方式

考虑到上面的颜色可以抽象出一个返回颜色的方法，因此可以将颜色抽象出一个接口放在形状中，简化代码

颜色类

抽象

public interface Color {

    String returnColor();
}

黑色

public class Black implements Color{

    public String returnBlackColor() {
        return "black";
    }

    @Override
    public String returnColor() {
        return "black";
    }
}

红色

public class Red implements Color{

    public String returnRedColor() {
        return "red";
    }

    @Override
    public String returnColor() {
        return "red";
    }
}

白色

public class White implements Color{

    public String returnWhiteColor() {
        return "white";
    }

    @Override
    public String returnColor() {
        return "white";
    }
}

形状类

圆形

public class Circle {


   public void getColorCircle(Color color) {
      System.out.println(color.returnColor()+ " circle");
   }
}

长方形

public class Rectangle {

    public void getColorRectangle( Color color) {
        System.out.println(color.returnColor() + " rectangle");
    }

}

正方形

public class Square {

    public void getColorSquare(Color color) {
        System.out.println(color.returnColor() + " square");
    }
}

测试类

public static void main(String[] args) {
        //获取红色的长方形
        Rectangle rectangle = new Rectangle();
        rectangle.getColorRectangle(new Red());

        //获取白色的圆
        Circle circle = new Circle();
        circle.getColorCircle(new White());

优化后

增加颜色类的时候不形状类里面不需要关注,基本可以实现后续增加形状或者颜色都不需要关注对方的改动，但是还是把颜色入侵到了形状里面，有一定的耦合度

3 使用桥接模式优化

颜色类

颜色接口

public interface Color {

    String returnColor();
}

黑色

public class Black implements Color{

    public String returnBlackColor() {
        return "black";
    }

    @Override
    public String returnColor() {
        return null;
    }
}

红色

public class Red implements Color {

    public String returnRedColor() {
        return "red";
    }

    @Override
    public String returnColor() {
        return "red";
    }
}

白色

public class White implements Color {

    public String returnWhiteColor() {
        return "white";
    }

    @Override
    public String returnColor() {
        return "white";
    }
}

形状类

抽象形状类

public abstract class Shape {

    Color color;

    public void setColor(Color color) {
        this.color = color;
    }

    public abstract void getColorShape();
}

圆形

public class Circle extends Shape{

   @Override
   public void getColorShape() {
      System.out.println(color.returnColor()+ " circle");
   }
}

长方形

public class Rectangle extends Shape {

    @Override
    public void getColorShape() {
        System.out.println(color.returnColor() + " rectangle");
    }
}

正方形

public class Square extends Shape {

    @Override
    public void getColorShape() {
        System.out.println(color.returnColor() + " square");
    }
}

测试类

public static void main(String[] args) {
        //获取红色的长方形
        Shape rectangle = new Rectangle();
        rectangle.setColor(new Red());
        rectangle.getColorShape();

        //获取白色的圆
        Shape circle = new Circle();
        circle.setColor(new White());
        circle.getColorShape();
    }

优化后

后续扩展添加颜色和形状都不会影响原有逻辑，具体的颜色和形状之间也没有直接的耦合了

##总结

桥接模式的使用可以减少类直接的耦合度，为后续的扩展提供方便，双方类如何变化都不会影响