十二、使用接口实现继承体系中的完全解耦

抽象类

使用关键字abstract可以定义一个抽象类，定义抽象类的好处是可以使类的抽象性更加明确，举个栗子，现在的场景是要将各种乐器演奏起来，那么我们可以创建一个乐器类作为所有乐器的超类，创建具体某个乐器（如：鼓，弦乐等）的类，并使其继承乐器类，不管是超类还是具体的类都带有演奏方法（play()方法），事实上，乐器类的play()方法并不需要具体实现，因为创建一个乐器类对象是没有意义的，抽象类就是为此而产生的。

abstract class Instrument {
    private i;
    public abstract void play() {}
    public String What() {
        return "Instrument";
    }
}

class Wind extends Instrument {
    public abstract void play() {
        System.out.println("Wind_play");
    }
    public String What() {
        return "Wind";
    }
}
class Stringed extends Instrument {
    public abstract void play() {
        System.out.println("Stringed_play");
    }
    public String What() {
        return "Stringed";
    }
}

public class music {
    public static void tune(Instrument i) {
        i.play();
        i.What();
    }

    public static void main(String [] args) {
        Wind w = new Wind();
        Stringed s = new Stringed();
        tune(w);
        tune(s);
    }
}

观察代码可以发现，除了基类，事实上并没有什么改变，抽象类在重构方面也是一个很重要的手段。

接口

使用interface关键字可以定义一个接口，接口比抽象类更具抽象性，抽象类中允许创建一个或多个无具体实现的方法。而接口是一个完全抽象类，它只允许创建者声明确定方法名，参数等，但是不能有方法体。

实现一个接口需要使用implements关键字。

还是以乐器为例子：

interface Instrument {
    int VALUE = 5;// 在接口中的常量都是 static+final 的
    public abstract void play();
    public String What();
}

class Wind implement Instrument {
    public abstract void play() {
        System.out.println("Wind_play");
    }
    public String What() {
        return "Wind";
    }
}
class Stringed implement Instrument {
    public abstract void play() {
        System.out.println("Stringed_play");
    }
    public String What() {
        return "Stringed";
    }
}

public class music {
    public static void tune(Instrument i) {
        i.play();
        i.What();
    }

    public static void main(String [] args) {
        Wind w = new Wind();
        Stringed s = new Stringed();
        tune(w);
        tune(s);
    }
}

注意：

1. 在接口中所有方法都是 public 的
2. 接口中的成员变量默认均是 static + final 的，因此都是常量。

使用接口实现完全解耦

首先来看一个栗子，理解一下为什么这个栗子的代码是高耦合的，而将接口应用于这个例子后却能实现解耦呢？

//一个通用数据处理器
class Processor{
    public String name(){
        return getClass().getSimpleName();
    }
    
    Object process(Object input){
        return input;
    }
}
//将数据处理为大写
class Upcase extends Processor{
    String process(Object input){
        return ((String)input).toUpperCase();
    }
}
//将数据都处理为小写
class Downcase extends Processor{
    String process(Object input){
        return ((String)input).toLowerCase();
    }
}
//将数据以空格为分隔符分割成字符串数组
class Splitter extends Processor{
    String process(Object input){
        return Arrays.toString(((String)input).split(" "));
    }
}

public class Apply{
    //待处理数据
    public static String s="this is a Sup--Sub Coupling";
    
    //数据统一加工入口
    public static void process(Processor p,Object s){
        System.out.println("Using Processor"+p.name());
        System.out.println(p.process(s));
    }
    
    public static void main(String[] args){
        process(new Upcase(),s);
        process(new Downcase(),s);
        process(new Splitter(),s);
    }
}

上例中实际上是策略设计模式的一个例子，面对一个具体的数据，可以有三种策略来处理，分别对应三种数据处理器（转换为大写，转换为小写，转换为数组）。

看懂了代码，我们再来考虑一下之前的问题，这个代码为什么是高耦合的，是什么和什么直接耦合过紧呢？

答案是Apply.process()方法和Processor之间耦合过紧，因为Processor是一个类，并且是这个继承体制中的基类，而Apply.process()方法接受一个Processor对象作为参数。

如此一来，如果其他继承体系中的类想要复用Apply.process()方法就做不到了。因为其他继承体制中的类不能同时再继承Processor，即便类中的方法和变量与Processor一模一样。

那么我们再次回到开头的问题中，考虑一下如何使用接口来解耦，为什么使用接口可以解耦呢？

我们可以把Processor定义为接口，也就是将Processor从原本的继承体系中再次抽象出来，一个接口可以理解为一个部件，或一个具有特定功能的零件，我们可以在任何类中将任意接口组装上去，使这个类具有这个接口所定义的功能。

interface Processor{
    public String name();
    Object process(Object input);
}
public class Apply{
    //数据统一加工入口
    public static void process(Processor p,Object s){
        System.out.println("Using Processor"+p.name());
        System.out.println(p.process(s));
    }
}

这样一来，如果有其他继承体系中的类的对象想要复用Apply.process()方法，就简单的多了，只要实现Processor接口即可。

拓展：适配器模式

我们再来思考一个问题，假设我们现在有一个Filter类的继承体系想要复用Apply.process()方法，但是该继承体系是第三方类库中的，我们无法直接对它进行修改，那该如何操作呢？

我们可以创建一个适配器类，通过这个适配器来间接复用Apply.process()方法：

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

public class Filter {
    public String name() {
        return getClass().getSimpleName();
    }
    public Waveform process(Waveform input) {
        return input;
    }
}

public calss LowPass extends Filter {
    double cutoff;
    LowPass(double cutoff) {
        this.cutoff = cutoff;
    }
    public Waveform process(Waveform input) {
        return input;
    }
}

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

class FilterAdapter implements Processor {
    Filter filter;
    public FilterAdapter(Filter filter) {
        this.filter = filter;
    }
    //上面适配了 Filter 对象，下面适配了 Processor 接口的方法，而方法的具体实现是使用了 Filter 对象的方法
    // 因此做到了将两个毫不相干的类和接口有机结合起来
    public String name() {
        return filter.name();
    }
    Object process(Object input) {
        return filter.process((Waveform)input);
    }
}

public class FilterProcessor {
    public static void main(String [] agrs) {
        Waveform w = new Waveform();
        //此处使用实现了Processor中方法的适配器来作为参数，而适配器中适配的方法中使用了 Filter 对象
        Apply.process(new FiterAdapter(new LowPass(1.0)), w);
        Apply.process(new FiterAdapter(new HighPass(1.0)), w);
    }
}