总结接口与接口引申出的几种设计模式

接口

接口的概念和使用应该很熟悉，但是设计模式和接口的真正意义一直很模糊，所以总结一下。总之就是使用接口可以使自己的代码复用性更好。

引申出的三种设计模式

创建一个能够根据所传递的参数对象的不同而具有不同行为的方法：被称为策略设计模式。这类方法包含要执行的算法中固定不变的部分，而“策略”包含变化的部分。策略就是传递进去的参数对象，它包含要执行的代码

适配器设计模式：无法修改你想要使用的类，可以使用适配器设计模式。适配器中的代码将接受你所拥有的接口，并产生你所需要的接口
将接口从具体实现中解耦使得接口可以应用于多种不同的具体实现，从而提高复用性

工厂方法设计模式：接口是实现多重继承的途径，而生成遵循某个接口的对象的典型方式就是工厂方法设计模式。这与知己调用构造器不同，我们在工厂对象上调用的是创建方法，而该工厂对象将生成接口的某个实现的对象。理论上，我们的代码将完全与接口的实现分离，这就使得我们可以透明的将某个实现替换为另一种实现。

代码

代码中Processor对象就是一个策略，在main()中可以看到三种不同类型的策略应用到了String类型的s对象上

/**
 * @Classname Porcessor
 * @Description 創建一个能够根据所传递的参数对象的不同而具有不同的行为的方法：被称为策略设计模式
 * @Date 2021/3/17 18:35
 * @Created by gt
 */
public class Porcessor {
    public String name(){
        return getClass().getSimpleName();
    }
    Object process(Object input){
        return input;
    }
}
class Upcase extends Porcessor{
    String process(Object input){
        return ((String) input).toUpperCase();
    }
}
class Downcase extends Porcessor{
    String process(Object input){
        return ((String) input).toLowerCase();
    }
}

class Splitter extends Porcessor {
    String process(Object input) {
        return Arrays.toString(((String) input).split(" "));
    }
}

class Apply {
    public static void process(Porcessor p, Object s) {
        System.out.print("using processor " + p.name());
        System.out.println(p.process(s));
    }
    public static String s = "====i love u====";

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

适配器设计模式

上述Apply.process()和Processor耦合过紧，想要复用Apply.process()方法代码时，复用被禁止了。将Processor类改为接口，这种限制就会变得容易，下面是修改版本

public interface ProcessorI {
    String name();
    Object process(Object input);
}
class Apply {
    public static void process(ProcessorI p, Object s) {
        System.out.print("using processor " + p.name());
        System.out.println(p.process(s));
    }
    public static String s = "====i love u====";

    public static void main(String[] args) {
    }
}

代码复用

/**
 * @Classname FilterAdapter
 * @Description 复用代码的第一种方式是客户端程序员遵循该接口来编写他们自己的类
 * @Date 2021/3/17 21:25
 * @Created by gt
 */
public class FilterAdapter implements ProcessorI {
    Filter filter;

    public FilterAdapter(LowPass filter) {
        this.filter = filter;
    }
    @Override
    public String name() {
        return filter.name();
    }

    @Override
    public Waveform process(Object input) {
        return filter.process((Waveform) input);
    }
}
class Waveform{
    private static long counter;
    private final long id = counter++;
    public String toString(){
        return "Waveform" + id;
    }
}
class Filter{
    public String name(){
        return getClass().getSimpleName();
    }
    public Waveform process(Waveform input){
        return input;
    }
}

class LowPass extends Filter{
    double aDouble;
    public LowPass(double aDouble) {
        this.aDouble = aDouble;
    }

    public Waveform process(Waveform input) {
        return input;
    }
}
class FilterProcessor{
    public static void main(String[] args) {
        Waveform w = new Waveform();
        Apply.process(new FilterAdapter(new LowPass(1.0)),w);
    }
}

上述电子滤波器使用到了适配器设计模式，适配器中的代码将接受你所拥有的接口（Filter），并产生你所需要的（ProcessorI接口）
将接口从具体实现中解耦使得接口可以应用于多中不同的具体实现，因此代码更具有复用性

工厂代码

/**
 * @Classname Factories
 * @Description 工厂方法
 * @Date 2021/3/21 23:10
 * @Created by gt
 */
public class Factories {
    public static void serviceConsumer(ServiceFactory fact){
        Service s = fact.getService();
        s.method();
    }
    public static void main(String[] args) {
        serviceConsumer(new Implementation1Factory());
        serviceConsumer(new Implementation2Factory());
    }
}

interface Service{
    void method();
}
interface ServiceFactory{
    Service getService();
}
class Implementation1 implements Service{
    Implementation1(){
    }

    @Override
    public void method() {
        System.out.println("Implementation1 method");
    }
}

class Implementation1Factory implements ServiceFactory {

    @Override
    public Service getService() {
        return new Implementation1();
    }
}

class implementation2 implements Service {
    implementation2() {
    }

    @Override
    public void method() {
        System.out.println("Implementation2 method");
    }
}

class Implementation2Factory implements ServiceFactory {

    @Override
    public Service getService() {
        return new implementation2();
    }
}

以上内容自己整理于Thing In Java接口一章内容