【Java编程思想读书笔记】第九章：接口

参考书目：《Java编程思想》（第四版）

阅读《Java编程思想》（第四版）一书收获颇多，之所以想通过用博客记笔记的方式来读书，是因为这样可以倒逼自己仔细、反复地阅读书中的知识，找相对意义上的重点，并且由于人脑更适合输出型的学习，通过将内容边看、边记、边理解和边打字写文，相比直接反复阅读更有效益（当然这本书后续仍需反复阅读几十遍甚至百遍以上都不为过），而另一个原因就是这样也能够在阅读中通过博客来记录自己的学习历程，博客记录的不只是图文，它们记录的正是自己的成长，等以后毕业或者工作后，回首大学四年，多少有点可以回念的东西，还可以说一句：一路走来，我读了很多前辈们的好书，对技术充满了热情，永远在不断学习的路上。

start.作者讲授思路：

（声明：由于本章很多接口的内容都是必备的基础，然而对于设计模式的几个代码示例写的很有代表性，让我有整理下来的冲动，因此，本文虽名为接口章节，实则为三种设计模式的例子）。

一、策略设计模式

创建一个能够根据所传递的参数对象的不同而具有不同行为的方法，被称为策略设计模式。这类方法包含所要执行的算法中固定不变的部分，而“策略”包含变化的部分。策略就是传递进去的参数对象，它包含要执行的代码，本例中，Processor对象就是一个策略，在main()中有三种不同类型的策略应用到了String类型的s对象上。

import java.util.Arrays;

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 void process(Processor p, Object s) {
        System.out.println("Using Process " + p.name());
        System.out.println(p.process(s));
    }

    public static String s = "hhh";

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

二、适配器设计模式

用到了代理。

//class LowPass extends Filter{}
//class HighPass extends Filter{}
//...
class FilterAdapter implements Processor {
	Filter filter;
	public FilterAdapter(Filter filter) {
		this.filter = filter;
	}
	public String name() { return filter.name(); }
	public Waveform process(Object input) {
		return filer.process((Waveform)input);
	}
}

三、工厂方法设计模式

在工厂对象上调用的是创建方法，而该工厂对象将直接生成接口的某个实现的对象。通过这种方式，我们的代码将完全与接口的实现分离。如果不是工厂方法，我们就必须指定要创建的Service的确切类型，以便调用合适的构造器。

我们通过添加这种额外级别的间接性，可以用于创建框架。

interface Service {
    void method();
}

interface Factory {
    Service getService();
}

class AService implements Service {
    public void method() {
        System.out.println("AService method1");
    }
}

class BService implements Service {
    public void method() {
        System.out.println("BService method1");
    }
}

class AFactory implements Factory {
    public Service getService() {
        return new AService();
    }
}

class BFactory implements Factory {
    public Service getService() {
        return new BService();
    }
}

public class Factories {
    public static void serviceConsumer(Factory fact) {
        Service s = fact.getService();
        s.method();
    }

    public static void main(String[] args) {
        serviceConsumer(new AFactory());
        serviceConsumer(new BFactory());
    }
}

忠告：

任何抽象性都应该是应真正的需求而产生的。

优先选择类而不是接口，从类开始，如果接口的必需性变得非常明确，那么就进行重构。

接口是一种重要的工具，但容易被滥用。