接口中的适配器设计模式(二)

Leefs 2019-10-20 AM 2666℃ 1条

### 二、适配器设计模式

### 前言

通过上一篇文章中，可以实现在Filter类中使用Apply.process()方法，但是这样造成的后果也是巨大的，因为在平时写代码时Processor是不可改写的，那么怎么能不再改写代码的前提下又能实现Filter类对Apply.process()方法的复用呢？

下面我们对以下代码做一个分析

代码:

> FilterProcessor.java

```java
class FilterAdapter implements Processor{

Filter filter;
    public FilterAdapter(Filter filter){
        this.filter=filter;
    }
    @Override
    public String name() {
        return filter.name();
    }
    @Override
    public Waveform process(Object input) {
        return (Waveform) filter.process(input);
    }
}
public class FilterProcessor {
    public static void main(String[] args) {
        Waveform waveform = new Waveform();    -- ①
        Apply.process(new FilterAdapter(new LowerPass(1.0)), waveform);-- ②
        Apply.process(new FilterAdapter(new HighPass(1.0)), waveform);-- ③
        Apply.process(new FilterAdapter(new BandPass(3.0,4.0)), waveform);
    }
}
```

添加一个适配器，让FilterAdapter类继承Processor类，然后将Filter类或者Filter类的子类对象传入到FilterAdapter类。

**适配器将做到：接受你所拥有的接口，并产生你所需要的接口。**

> Filter.java

```java
public class Filter{
    public String name(){
        return getClass().getSimpleName();
    }

public Waveform process(Waveform input) {
        return input;
    }
}
```

> BandPass.java

```java
public class BandPass extends Filter {
    double lowCutoff,hightCutoff;
    public BandPass(double lowCutoff,double hightCutoff){
        this.lowCutoff = lowCutoff;
        this.hightCutoff = hightCutoff;
    }
    public Waveform process(Waveform input){
        return input;
    }
}
```

> HighPass.java

```java
public class HighPass extends Filter {
    double cutoff;
    public HighPass(double cutoff){
        this.cutoff = cutoff;
    }
    public Waveform process(Waveform input){
        return input;
    }
}
```

> Apply.java

```java
class Processor {

public String name() {
        return getClass().getSimpleName();
    }

Object process(Object input) {
        return input;
    }
}

class Upcase extends Processor {
    String process(Object input) { // Covariant return
        return ((String) input).toUpperCase();
    }
}

class Downcase extends Processor {
    String process(Object input) {
        return ((String) input).toLowerCase();
    }
}

class Splitter extends Processor {
    String process(Object input) {
        // The split() argument divides a String into pieces:
        return Arrays.toString(((String) input).split(" "));
    }
}

public class Apply {
    public static void process(Processor p, Object s) {
        System.out.println("Using Processor " + p.name());
        System.out.println(p.process(s));
    }

public static String s =
            "Disagreement with beliefs is by definition incorrect";

public static void main(String[] args) {
        process(new Upcase(), s);
        process(new Downcase(), s);
        process(new Splitter(), s);
    }
}
```

> LowerPass.java

```java
public class LowerPass extends Filter {
    double cutoff;
    public LowerPass(double cutoff){
        this.cutoff = cutoff;
    }
    public Waveform process(Waveform input){
        return input;
    }
}
```

> Waveform.java

```java
public class Waveform {
    private static long counter;
    private final long id=counter++;
    public String toString(){
        return "Waveform:"+id;
    }
}
```

> 运行结果

```java
Using Processor LowerPass
Waveform:0
Using Processor HighPass
Waveform:0
Using Processor BandPass
Waveform:0
```
（代码来自Think in Java P177）

> 代码执行流程

1. 1.创建Waveform对象，在内存中为其分配内存空间
   + 给Wavefom类中的id赋值
2. 2.执行语句②
   + 创建LowerPass对象并为其参数赋值为1
   + 对LowerPass对象的父类Filter进行初始化操作
   + 执行LowerPass对象的构造方法
   + 创建FilterAdapter对象
   + 执行FilterAdapter的父类Processor的构造方法
   + 执行FilterAdapter类的构造方法
   + 调用Apply.process()静态方法
   + 执行p.name()
   + 执行FilterAdapter类中的name()方法
   + ==调用Filter类中的name()方法==
   + 打印输出**Using Processor LowerPass**
   + 执行p.process()方法
   + 执行FilterAdapter类中的process()方法
   + ==执行LowerPass类中的process方法==
   + 执行Waveform对象中的toString()方法
   + 打印输出**Waveform:0**

3. 3.执行语句③

.......

### 总结

通过上方的代码执行流程分析，我们可以知道FilterAdapter的构造器接受你所拥有的接口Filter,然后生成具有你所需要的Processor接口的对象。你可能还注意到了，在FilterAdapter类中用到了代理。

通过添加适配器实现了代码的完全解耦，增强了代码的复用性。

标签: Java, Java编程思想, JavaSE

非特殊说明，本博所有文章均为博主原创。

如若转载，请注明出处：https://lilinchao.com/archives/43.html

上一篇接口中的适配器设计模式(一)

下一篇接口相关练习题

取消回复

评论啦~

唉呀 ~ 仅有一条评论

Leefs 博主

Doing the things you want to do.
回复 2019-10-20 10:23

接口中的适配器设计模式(二)

评论啦~

唉呀 ~ 仅有一条评论

栏目分类

标签云

友情链接申请

接口中的适配器设计模式(二)

 评论啦~

唉呀 ~ 仅有一条评论

 栏目分类

标签云

友情链接申请

评论啦~

栏目分类

标签云

友情链接申请