桥接模式（组合替代继承）

目录

前言

UML

plantuml

类图

实战代码

适配器模式

举个例子

Weapon

Shoes

People

Client

---

前言

桥接模式，其实就是组合替代继承思想的实现。

在不用桥接模式时，设计一个类如果想复用现有类的功能，并且再扩展新的方法，最容易想到的就是使用继承，子类继承父类，子类复用父类的方法，再自己实现扩展方法。

使用继承确实可以实现需求，不过同样存在很大的缺陷：

1. 如果想要复用的类有多个时，就无法实现了，因为 Java 是单继承
2. 子类继承了父类的所有方法，而父类并不是所有方法都适用于子类，违背了接口隔离原则，同时，子类还可能会修改污染父类的方法，违背里氏替换原则
3. 使用继承复用父类的方法，无法在运行时改变，不够灵活

使用桥接模式，将抽象部分与它的实现部分分离，以便它们可以独立地变化。桥接模式可以将继承关系转换为关联关系，从而提高了程序的灵活性和可扩展性。

UML

plantuml

@startuml
'https://plantuml.com/class-diagram

interface Implementor {
    + method() : void
}

class ConcreteImplementorA {
    + method() : void
}

class ConcreteImplementorB {
    + method() : void
}

class Abstraction {
    - implementor : Implementor
    + Abstraction(Implementor)
}

class Client {}

Implementor <|.. ConcreteImplementorA
Implementor <|.. ConcreteImplementorB

Abstraction "1" --> "1" Implementor

Client ..> Abstraction

@enduml

类图

实战代码

适配器模式

适配器模式是一个最简单的例子

适配器模式实战运用-CSDN博客

举个例子

用RPG中的人物装备系统来举例，角色可以拥有武器，鞋子等装备。

这里抽象出武器和鞋子两个接口，Weapon 和 Shoes

角色类为 People，实现 Weapon 和 Shoes

Weapon

interface Weapon {
    void show();
}
 
class Sword implement Weapon {
    @Override
    void show() {
        System.out.println("Sword");
    }
}
 
class Gun implement Weapon {
    @Override
    void show() {
        System.out.println("Gun");
    }
}

Shoes

interface Shoes {
    void show();
}
 
class Slippers implement Shoes {
    @Override
    void show() {
        System.out.println("Slippers");
    }
}
 
class Sneakers implement Shoes {
    @Override
    void show() {
        System.out.println("Sneakers");
    }
}

People

public class People {
    orivate String name;
    private Weapon weapon;
    private Shoes shoes;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name= name;
    }

    public Weapon getWeapon() {
        return weapon;
    }

    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }

    public Shoes getShoes() {
        return shoes;
    }

    public void setShoes(Shoes shoes) {
        this.shoes = shoes;
    }

    public void showWeapon() {
        weapon.show();
    }

    public void showShoes() {
        shoes.show();
    }
}

Client

public class Client {
    public static void main(String[] args) {
        People people = new People();
        people.setName("test");
        people.setWeapon(new Sword());
        people.setShoes(new Slippers());

        people.showWeapon();
        people.showShoes();

        people.setWeapon(new Gun());
        people.setShoes(new Sneakers());

        people.showWeapon();
        people.showShoes();
    }
}

Weapon 和 Shoes 是本例的抽象部分，作为 People 的成员变量，具体的实现由客户端传入，从而将抽象部分与它的实现部分分离，以便它们可以独立地变化。

相较于继承，使用组合能够使程序更加灵活和可扩展。