## 高阶函数 这个名字可能听起来令人生畏，但是：[高阶函数](https://en.wikipedia.org/wiki/Higher-order_function)（Higher-order Function）只是一个消费或产生函数的函数。 我们先来看看如何产生一个函数： ~~~java // functional/ProduceFunction.java import java.util.function.*; interface FuncSS extends Function<String, String> {} // [1] public class ProduceFunction { static FuncSS produce() { return s -> s.toLowerCase(); // [2] } public static void main(String[] args) { FuncSS f = produce(); System.out.println(f.apply("YELLING")); } } ~~~ 输出结果： ~~~ yelling ~~~ 这里，`produce()`是高阶函数。 **\[1\]**使用继承，可以轻松地为专用接口创建别名。 **\[2\]**使用 Lambda 表达式，可以轻松地在方法中创建和返回一个函数。 要消费一个函数，消费函数需要在参数列表正确地描述函数类型。代码示例： ~~~java // functional/ConsumeFunction.java import java.util.function.*; class One {} class Two {} public class ConsumeFunction { static Two consume(Function<One,Two> onetwo) { return onetwo.apply(new One()); } public static void main(String[] args) { Two two = consume(one -> new Two()); } } ~~~ 当基于消费函数生成新函数时，事情就变得相当有趣了。代码示例如下： ~~~java // functional/TransformFunction.java import java.util.function.*; class I { @Override public String toString() { return "I"; } } class O { @Override public String toString() { return "O"; } } public class TransformFunction { static Function<I,O> transform(Function<I,O> in) { return in.andThen(o -> { System.out.println(o); return o; }); } public static void main(String[] args) { Function<I,O> f2 = transform(i -> { System.out.println(i); return new O(); }); O o = f2.apply(new I()); } } ~~~ 输出结果： ~~~ I O ~~~ 在这里，`transform()`生成一个与传入的函数具有相同签名的函数，但是你可以生成任何你想要的类型。 这里使用到了`Function`接口中名为`andThen()`的默认方法，该方法专门用于操作函数。 顾名思义，在调用`in`函数之后调用`andThen()`（还有个`compose()`方法，它在`in`函数之前应用新函数）。 要附加一个`andThen()`函数，我们只需将该函数作为参数传递。`transform()`产生的是一个新函数，它将`in`的动作与`andThen()`参数的动作结合起来。