关于解耦的思考

前言
以前记得在知乎上看过，一个神奇的例子，大致上来说就是一个手机接触到了金属汤匙，结果手机显示检测的未知设备。其实从一方面看来这也算是一个代码复用的思想吧。

在设计程序的时候，我们都会尽力提高代码的复用性，这也导致在方法中会产生依赖的关系，但是对于使用者而言，依赖关系会添加诸多的限制，因此在设计程序的时候会倾向于高内聚，低耦合，内聚是模块内部自身各个元素的紧密联系，而低耦合则倾向于减少模块于模块之间的依赖关系从而让使用者的限制减少。
关于解耦的方式现在一般倾向于利用面向接口的形式实现,而不是利用类，因为一是如果使用类的结果便是传入的参数必须是该类的本身或子类的对象，这便产生了一定的约束也就是耦合，二是这样可能会暴露一些实例域中的数据，而如果使用接口的话，可以在很大程度上减少这种耦合关系。
这里假设以类继承实现代码的复用：

public class Slot {
    public void  doSomething() {
            System.out.println("Interface");
    }
}

public class TypeC extends  Slot{
    @Override
    public void doSomething() {
        System.out.println("TypeC");
    }
}

public class USB  extends  Slot {
    @Override
    public void doSomething() {
        System.out.println("TypeC");
    }
}

public class Apply {

    public static void insert(Slot inter) {
        System.out.println(inter.getClass().getName());
        inter.doSomething();
    }
    public static void main(String[] args) {
        insert(new TypeC());
        insert(new USB());
    }
}

我们在为了使apply的insert方法提高复用性，会根据传入对象的不同执行不同的功能，这也是一种策略模式，但是同样的产生了一定的约束：要求传入的对象必须是Slot或其子类对象，这就产生了比较明显的耦合过程，如果我们有一个类有doSomething（）的方法但是已经继承了其他的父类对象，这就比较麻烦了。

public class Basic {
    private String name;
    public Basic(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

public class Others extends Basic {
    public Others(String name) {
        super(name);

    }

    public void  doSomething() {
        System.out.println("others");
    }
}

这个时候本来的思想是apply.的insert方法应该有很高的复用性但是对于Others类就明显的无法执行，这也就是耦合比较高的体现，当然也可以解决这种情况，那便是为Others设计一个adapter从而适配这个apply的insert

public class OtherAdapter extends Slot {
        Others others;
        public  OtherAdapter(Others others) {
            super();
            this.others = others;
        }
        @Override
        public void doSomething() {
            others.doSomething();
        }
}

不过也是由于耦合较高因此不得不使用一个适配器来实现，但是如果使用接口的话可以大大降低这种耦合程度

public interface Slot {
    public void  doSomething();
}

那么只要实现这个接口便可以

public class Others extends Basic implements Slot {
    public Others(String name) {
        super(name);

    }

    public void  doSomething() {
        System.out.println("others");
    }
}

这样apply的insert便也可以接受。并且除了这个好处以外，如果我们不能对others进行修改的化，我们可以利用适配器实现

public class OtherAdapter implements Slot {
        Others others;
        public  OtherAdapter(Others others) {
            super();
            this.others = others;
        }
        @Override
        public void doSomething() {
            others.doSomething();
        }
}

(当然这里的适配器用的是代理，如果想依然可以利用OtherAdapter继承Others来实现适配)这样我们可以对这个OtherAdapter进行更高程度的扩展了，而如果用以前的类继承的化就会有一定程度上的限制了。所以接口可以才很大程度上减轻耦合。