Java 设计模式_适配器模式

Java 设计模式_适配器模式

---

本文由 Luzhuo 编写,转发请保留该信息.
原文: http://blog.csdn.net/Rozol/article/details/76154881

---

将一个类的接口转换成期望的另一个接口,使其能够兼容使用
适配器模式分为: 对象适配器模式 / 类适配器模式 / 缺省适配模式
对象适配器: 将一个接口转成期望的另一个接口
类适配器器: 将一个类转成期望的另一个接口
缺省适配器: 为一个接口提供缺省实现,子类可以重写部分缺省实现进行具体实现

对象适配器模式

public interface OldTarget {
    void show1();
}

public class OldTargetImpl implements OldTarget {
    @Override
    public void show1() {
        System.out.println("OldTargetImpl");
    }
}

• 以上是旧的接口和接口的实现类,但是现在需要使用新接口,我们需要将旧接口(OldTarget) 转为新接口(Target),让他们能够兼容被使用.

public interface Target {
    void show1();
    void show2();
}

public class TargetAdapter implements Target{

    private OldTarget mAdaptee;

    public TargetAdapter(OldTarget adapter){
        mAdaptee = adapter;
    }

    @Override
    public void show1() {
        mAdaptee.show1();
    }

    @Override
    public void show2() {
        System.out.println("TargetAdapter");
    }
}

• 对象适配器(TargetAdapter)就在这里起到了,将OldTarget接口转为我们期望使用的Target,并使旧接口与新接口兼容被使用的

类适配器模式

public class OldClass {
    public void show1(){
        System.out.println("OldClass");
    }
}

• 以上是旧的类(OldClass), 我们期望使用新的接口(ClassTarget), 需要将类转为该接口, 使其能够兼容被使用

public interface ClassTarget {
    void show1();

    void show2();
}

public class ClassAdapter extends OldClass implements ClassTarget{

    @Override
    public void show2() {
        System.out.println("ClassAdapter");
    }

}

• 类适配器(ClassAdapter), 在这里起到了将旧的类(OldClass), 转为了我们期望使用的目标接口(ClassTarget), 并使旧类和新接口能够兼容被使用

缺省适配模式

public interface Interfaces {
    public abstract void show1();
    public abstract void show2();
    public abstract void show3();
    public abstract void show4();
    public abstract void show5();
}

• 这个接口里定义了n个方法, 我们期望子类能够根据自身需要重写他, 而不是重写全部的未实现方法

public class InterfacesAdapter implements Interfaces{
    @Override
    public void show1(){}
    @Override
    public void show2(){}
    @Override
    public void show3(){}
    @Override
    public void show4(){}
    @Override
    public void show5(){}
}

• 缺省适配器(InterfacesAdapter),就在这起到了, 子类只需重写适配器里的部分自身所需要的方法, 对其进行实现

使用

public class Test {
    public static void main(String[] args) {

        // 对象适配器
        objAdapter();

        // 类适配器
        classAdapter();

        // 缺省适配器
        defaultAdapter();
    }

    /**
     * 将一个接口转成期望的另一个接口
     */
    private static void objAdapter() {
        TargetAdapter adapter = new TargetAdapter(new OldTargetImpl());

        adapter.show1();
        adapter.show2();
    }

    /**
     * 将一个类转成期望的另一个接口
     */
    private static void classAdapter() {
        ClassAdapter adapter = new ClassAdapter();
        adapter.show1();
        adapter.show2();
    }

    /**
     * 为一个接口提供缺省实现,子类可以重写部分缺省实现进行具体实现
     */
    private static void defaultAdapter(){
        new InterfacesAdapter(){
            public void show3() {
                System.out.println("Test - InterfacesAdapter");
            };
        }.show3();
    }
}