设计模式（四）——适配器模式、桥接模式

适配器模式
概念： 将一个接口转换成客户希望的另一个接口，使接口不兼容的那些类可以一起工作，其别名为包装器(Wrapper)。适配器模式既可以作为类结构型模式，也可以作为对象结构型模式。
参与者： Abstraction（抽象类）、RefinedAbstraction（具体抽象类）、Implementor（实现类）、ConcreteImplementor（具体实现类）

(1) 类适配器

package mypackage;

public class TestAdapterPattern {

    public static void main(String[] args) {
        Adapter adapter = new Adapter();
        adapter .target();
    }

}

class Adaptee {
    public void display() {
        System.out.println("This is an Adaptee");
    }
}

interface Target {
    void target();
}

class Adapter extends Adaptee implements Target {

    @Override
    public void target() {
        super.display();
    }

}

小结： 要想接口Target调用实体类Adaptee中的方法，有继承和组成两种方法，而类适配器使用的是继承Adaptee，因为接口必须被实现，最后在接口中实现过来的方法来调用Adaptee中的方法，中间类Adapter可以随时方便调用其方法。

(2) 对象适配器

package mypackage;

public class TestAdapterPattern {

    public static void main(String[] args) {
        Adapter adapter = new Adapter();
        adapter.setAdaptee(new Adaptee());
        adapter.target();
    }

}

class Adaptee {
    public void display() {
        System.out.println("This is an Adaptee");
    }
}

interface Target {
    void target();
}

class Adapter implements Target {
    protected Adaptee adaptee;

    @Override
    public void target() {
        adaptee.display();
    }

    public Adaptee getAdaptee() {
        return adaptee;
    }

    public void setAdaptee(Adaptee adaptee) {
        this.adaptee = adaptee;
    }
}

小结：对象适配器采用了组合的方法，将Adaptee注入到中间类Adapter中，可以方便调用其方法。

桥接模式
概念： 将抽象和实现解耦，使得两者可以独立的变化。
参与者： Abstraction（抽象类）、RefinedAbstraction（具体抽象类）、Implementor（实现类）、ConcreteImplementor（具体实现类）

package mypackage;

public class DesignPatternDemo {

    public static void main(String[] args) {
        Body body = new FootBallGame("foot", new PlayingFootBall());
        body.sport();
        body = new TableTennisGame("hand", new PlayingTableTennis());
        body.sport();
    }

}

// 灵魂和肉体是两个不同的维度 不是父子继承关系 但是要组合在一起才能共同完成事情
interface Soul {
    public void sport();
}

// 灵魂要参与运动 但是仅仅灵魂这一个维度没有办法去实现参与运动 比如 踢足球需要脚 打乒乓球需要手 但是手脚是属于肉体 所以必须把灵魂注入肉体中
class PlayingFootBall implements Soul {

    @Override
    public void sport() {
        System.out.println("playing football");
    }

}

class PlayingTableTennis implements Soul {

    @Override
    public void sport() {
        System.out.println("playing tableTennis ");
    }

}

// 同样 仅仅肉体这一个维度也没有办法完成踢足球和打乒乓球的运动 因为肉体只有手脚 没有思想 不知道要具体参与什么运动
abstract class Body {
    protected String organ;
    Soul soul;

    public Body(Soul soul) {
        this.soul = soul;
    }

    abstract void sport();

}

class FootBallGame extends Body {

    public FootBallGame(String organ, Soul soul) {
        super(soul);
        this.organ = organ;

    }

    @Override
    void sport() {
        soul.sport();
    }

}

class TableTennis Game extends Body {

    public TableTennis Game(String organ, Soul soul) {
        super(soul);
        this.organ = organ;
    }

    @Override
    void sport() {
        soul.sport();
    }

}

假如在这种模式下进行扩展，如下代码所示：

package mypackage;

public class DesignPatternDemo {

    public static void main(String[] args) {

        Body body = new FootBallGame("foot", new PlayingFootBall());
        body.sport();
        body = new TableTennis Game("hand", new PlayingTableTennis());
        body.sport();

        body = new VolleyBallGame("hand", new PlayingVolleyBall());
        body.sport();
    }

}

// 灵魂和肉体是两个不同的维度 不是父子继承关系 但是要组合在一起才能共同完成事情
interface Soul {
    public void sport();
}

// 灵魂要参与运动 但是仅仅灵魂这一个维度没有办法去实现参与运动 比如 踢足球需要脚 打乒乓球需要手 但是手脚是属于肉体 所以必须把灵魂注入肉体中
class PlayingFootBall implements Soul {

    @Override
    public void sport() {
        System.out.println("playing football");
    }

}

class PlayingTableTennis implements Soul {

    @Override
    public void sport() {
        System.out.println("playing tableTennis ");
    }

}

class PlayingVolleyBall implements Soul {

    @Override
    public void sport() {
        System.out.println("playing volleyball");
    }

}

// 同样 仅仅肉体这一个维度也没有办法完成踢足球和打乒乓球的运动 因为肉体只有手脚 没有思想 不知道要具体参与什么运动
abstract class Body {
    protected String organ;
    Soul soul;

    public Body(Soul soul) {
        this.soul = soul;
    }

    abstract void sport();

}

class FootBallGame extends Body {

    public FootBallGame(String organ, Soul soul) {
        super(soul);
        this.organ = organ;

    }

    @Override
    void sport() {
        soul.sport();
    }

}

class TableTennisGame extends Body {

    public TableTennisGame(String organ, Soul soul) {
        super(soul);
        this.organ = organ;
    }

    @Override
    void sport() {
        soul.sport();
    }

}

class VolleyBallGame extends Body {

    public VolleyBallGame(String organ, Soul soul) {
        super(soul);
        this.organ = organ;
    }

    @Override
    void sport() {
        soul.sport();
    }

}

总结

桥接模式
关键类：多个维度，各个维度父类和子类
继承关系：各个维度内父类和子类继承关系，便于面向接口编程，各个维度之间类与类没有关系，相互独立
组合关系：各个维度之间类与类使用组合注入方式联系

代理模式
关键类：代理类
继承关系：实体类和代理类都继承于同一父类，它们与父类是继承关系，便于客户端面向接口编程
组合关系：实体类和代理类之间是组合关系，将实体类引用注入代理类，在代理类中调用实体类方法或属性

装饰器模式
关键类：装饰类
继承关系：实体类和装饰类都继承于同一父类，它们与父类是继承关系，便于客户端面向接口编程
组合关系：实体类和装饰类之间是组合关系，将实体类引用注入装饰类，在装饰类中调用实体类方法或属性，还有装饰类自己新增的方法和属性