JAVA设计模式学习笔记---02

Java 设计模式学习笔记—02

适配器模式（Adapter）

• 将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
• 主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。
  • 类的适配器模式：
    • 
    • 有一个Source类，拥有一个方法，待适配，目标接口时Targetable，通过Adapter类，将Source的功能扩展到Targetable里。
  • 对象的适配器模式
    • 基本思路和类的适配器模式相同，只是将Adapter类作修改，这次不继承Source类，而是持有Source类的实例，以达到解决兼容性的问题。
    • 
  • 接口的适配器模式
    • 有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。
    • 
• 示例1：
• 
• ElectricAdapter.java

/**
 * 适配器：电能适配器
 */
public class ElectricAdapter implements Motor {
    private final ElectricMotor electric;

    public ElectricAdapter() {
        this.electric = new ElectricMotor();
    }

    @Override
    public void drive() {
        electric.electricDrive();
    }
}

• ElectricMotor.java

/**
 * 适配者：电能发动机
 */
public class ElectricMotor {
    public void electricDrive(){
        System.out.println("我是电能发动机，正在发动。。。");
    }
}

• Motor.java

/**
 * 目标接口：发动机
 */
public interface Motor {
    void drive();
}

• OpticalAdapter.java

/**
 * 适配器：光能适配器
 */
public class OpticalAdapter implements Motor {
    private final OpticalMotor optical;

    public OpticalAdapter() {
        this.optical = new OpticalMotor();
    }

    @Override
    public void drive() {
        optical.opticalDrive();
    }
}

• OpticalMotor.java

/**
 * 适配者：光能发动机
 */
public class OpticalMotor {
    public void opticalDrive(){
        System.out.println("我是光能发动机，正在发动。。。");
    }
}

• 双向适配
  • 结构图
  • 
• AdapteeRealize.java

/**
 * 适配者实现类：
 */
public class AdapteeRealize implements TwoWayAdaptee {
    @Override
    public void specificRequest() {
        System.out.println("适配者代码被调用！");
    }
}

• TargetRealize.java

/**
 * 目标实现：实现接口
 */
public class TargetRealize implements TwoWayTarget {
    @Override
    public void request() {
        System.out.println("目标代码被调用！");
    }
}

• TwoWayAdaptee.java

/**
 * 适配者接口：（双向适配器）
 */
public interface TwoWayAdaptee {
    void specificRequest();
}

• TwoWayAdapter.java

/**
 * 双向适配器：双向适配
 */
public class TwoWayAdapter implements TwoWayTarget, TwoWayAdaptee {
    private TwoWayAdaptee adaptee;
    private TwoWayTarget target;

    public TwoWayAdapter() {
    }

    public TwoWayAdapter(TwoWayAdaptee adaptee) {
        this.adaptee = adaptee;
    }

    public TwoWayAdapter(TwoWayTarget target) {
        this.target = target;
    }

    @Override
    public void specificRequest() {
        target.request();
    }

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

• TwoWayTarget.java

/**
 * 目标接口：（双向适配器模式）
 */
public interface TwoWayTarget {
    void request();
}

代理设计模式

• 代理模式的结构比较简单，主要是通过定义一个继承抽象主题的代理来包含真实主题，从而实现对真实主题的访问，下面来分析其基本结构和实现方法。
• 代理模式的主要角色如下。
  • 抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。
  • 真实主题（Real Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。
  • 代理（Proxy）类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。
  • 
• Subject.java

/**
 * 抽象主题
 */
public interface Subject {
    void request();
}

• RealSubject.java

/**
 * 真实主题
 */
public class RealSubject implements Subject{
    @Override
    public void request() {
        System.out.println("我是真实主题，正在被调用！");
    }
}

• Proxy.java

/**
 * 代理类
 */
public class Proxy implements Subject {
    private RealSubject realSubject;
    @Override
    public void request() {
        if(realSubject==null){
            realSubject = new RealSubject();
        }
        preRequest();
        realSubject.request();
        postRequest();
    }

    public void preRequest() {
        System.out.println("访问真实主题之前的预处理。");
    }

    public void postRequest() {
        System.out.println("访问真实主题之后的后续处理。");
    }
}

• 动态代理
• 参考