（二）结构型设计模式

1. 适配器模式

1.1 定义

将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。适配器模式分为类结构型模式和对象结构型模式两种，前者类之间的耦合度比后者高，且要求程序员了解现有组件库中的相关组件的内部结构，所以应用相对较少些。

对象适配器应用较多。

1.2 结构与实现

类适配器模式：可采用多重继承方式实现，Java不支持多继承，但可以定义一个适配器类来实现当前系统的业务接口，同时又继承现有组件库中已经存在的组件。

对象适配器模式：可釆用将现有组件库中已经实现的组件引入适配器类中，该类同时实现当前系统的业务接口。

主要角色：

1. 目标（Target）接口：当前系统业务所期待的接口，它可以是抽象类或接口。
2. 适配者（Adaptee）类：它是被访问和适配的现存组件库中的组件接口。
3. 适配器（Adapter）类：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者。

1.2.1 类适配器

public interface Target{
    void request();
}

public class Adaptee{
    public void specificRequest(){
        System.out.println("适配者中的业务代码被调用！");
    }
}

public class ClassAdapter extend Adpatee implements Target{
    public void request(){
        specificRequest();
    }
}
//客户端代码
public class ClassAdapterTest{
    public static void main(String[] args){
        System.out.println("类适配器模式测试：");
        Target target = new ClassAdapter();
        target.request();
    }
}

以手机充电器为例，充电插头就是适配器类ClassAdapter，手机所需要的5V电源就是目标，220V的交流电就是适配者类。在适配器类中，他继承适配者类，并实现目标，通过转换策略将220V的电压转换为5V的电压，供手机使用。（代码如下）

//适配器接口
public interface Voltage5V {
    public int output5V();
}

// 被适配的类（适配者）
public class Voltage220V {
    // 输出220V的电压
    public int output220V(){
        int src = 220;
        System.out.println("电压为"+src+"V");
        return src;
    }
}

// 适配器类，将220V电压转换为5V电压
public class VoltageAdapter extends Voltage220V implements Voltage5V{
    @Override
    public int output5V() {
        int src = output220V();     // 获取220V的电压
        System.out.println("220V的电压正在适配器中进行转换......");
        int dstV = src / 44;        // 将220V转为5V电压
        System.out.println("电压适配完成，适配完成后的电压为："+dstV+"V......");
        return dstV;                // 将转换后的电压返回
    }
}

1.2.2 对象适配器

对象适配器模式中的“目标接口”和“适配者类”的代码同类适配器模式一样，只要修改适配器类代码即可。

public interface Target{
    void request();
}

public class Adaptee{
    public void specificRequest(){
        System.out.println("适配者中的业务代码被调用！");
    }
}

public class ClassAdapter implements Target{
    private Adaptee adaptee;
    
    public ObjectAdapter(Adaptee adaptee){
        this.adaptee = adaptee;
    }
    
    public void request(){
        adaptee.specificRequest();
    }
}
//客户端代码
public class ObjectAdapterTest{
    public static void main(String[] args){
        System.out.println("对象适配器模式测试：");
        Adaptee adaptee = new Adaptee();
        Target target = new ObjectAdapter(adaptee);
        target.request();
    }
}

2. 桥接模式

2.1 定义

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

桥接模式遵循里氏替换原则和依赖倒置原则，最终实现了开闭原则，对修改关闭，对扩展开放。

因为父类拥有的方法，子类也会继承得到，无论子类需不需要，这说明继承具备强侵入性（父类代码侵入子类），同时会导致子类臃肿。因此，在设计模式中，有一个原则为优先使用组合/聚合，而不是继承。

2.2 结构与实现

将抽象化部分与实现化部分分开，取消二者的继承关系，改用组合关系。

主要角色：

1. 抽象化（Abstraction）角色：定义抽象类，并包含一个对实现化对象的引用。
2. 扩展抽象化（Refined Abstraction）角色：是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色中的业务方法。
3. 实现化（Implementor）角色：定义实现化角色的接口，供扩展抽象化角色调用。
4. 具体实现化（Concrete Implementor）角色：给出实现化角色接口的具体实现。

// 实现化角色
public interface Implementor{
    void OperationImpl();
}

// 具体实现化角色（Photoshop中图形的颜色A）
public class ConcreteImplementorA implements Implementor{
    public void OperationImpl(){
        System.out.println("具体实现化(Concrete ImplementorA)角色被访问");    
    }
}

// 具体实现化角色（Photoshop中图形的颜色B）
public class ConcreteImplementorB implements Implementor{
    public void OperationImpl(){
        System.out.println("具体实现化(Concrete ImplementorB)角色被访问");
    }
}

// 抽象化角色
public class Abstraction{
    protected Implementor imple = null;
    
    protected Abstraction(Implementor imple){
        this.imple = imple;
    }
    
    public abstract void Operation();
}

// 扩展抽象化角色（Photoshop中图形的形状）
public class RefinedAbstraction extend Abstraction{    
    protected RefinedAbstraction(Implementor imple){
       super(imple);
    }
    
    public void Operation(){
        System.out.println("扩展抽象化(Refined Abstraction)角色被访问");
        imple.operationImpl();
    }
}

public class BridgeTest {
    public static void main(String[] args) {
        Implementor imple = new ConcreteImplementorA();
        Abstraction abs = new RefinedAbstraction(imple);
        abs.Operation();
    }
}