内部类与函数式编程
首先，我们来看下策略模式，这是网上找到的一个关于策略模式的解释：策略模式是对算法的包装，是把使用算法的责任和算法本身分割开来，委派给不同的对象管理。策略模式通常把一个系列的算法包装到一系列的策略类里面，作为一个抽象策略类的子类。用一句话来说，就是：“准备一组算法，并将每一个算法封装起来，使得它们可以互换”。
这里不详细介绍策略模式，只是简单的用策略模式来引入函数式编程的例子。
通常，传递给方法的数据不同，结果不同。如果我们希望方法在调用时行为不同，该怎么做呢？结论是：只要能将代码传递给方法，我们就可以控制它的行为。
interface Strategy {
String approach(String msg);
}
class DefaultStrategy implements Strategy {
public String approach(String msg) {
return msg.toLowerCase() + "?";
}
}public class Strategize {
Strategy strategy = new DefaultStrategy();
String msg;
Strategize(String msg) {
this.msg = msg;
}
void communicate() {
System.out.println(strategy.approach(msg));
}
void changeStrategy(Strategy strategy) {
this.strategy = strategy;
}
}Strategize有一个默认的策略，当我们调用communicate时，就是使用默认的策略来处理msg。当然我们也可以更换Strategy从而让communicate表现不同的行为。在java 8之前我们除了像DefaultStrategy那样定义一个类之外，还可以通过定义一个匿名内部类来实现。
public static void main(String[] args) {
Strategize s = new Strategize("Hello there");
Strategy s = new Strategy() {
public String approach(String msg) {
return msg.toUpperCase() + "!";
}
};
s.communicate();
}在java 8中引入函数式编程后，上面的例子就可以用Lambda 表达式进行改写
public static void main(String[] args) {
Strategize s = new Strategize("Hello there");
Strategy s = msg -> msg.toUpperCase() + "!";
s.communicate();
}代码少多了，实现的效果和上面一样。
如果你想使用的策略已经存在其他类或对象中，还可以直接使用方法引用的方式来实现。如下面的例子。
public static void main(String[] args) {
Strategize s = new Strategize("Hello there");
Strategy s = String::toLowerCase;
s.communicate();
}Lambda 表达式和方法引用产生函数，而不是类。 虽然实际上在 JVM（Java Virtual Machine，Java 虚拟机）上，一切都是一个类，java 8在幕后执行各种操作使 Lambda 看起来像函数 —— 但作为程序员，你可以高兴地假装它们“只是函数”。意识到这一点很重要，我们使用Lambda 表达式和方法引用进行函数式编程时，不要和类联系起来，仅仅当它们是函数就可以了，这样更容易理解代码。
如果一个接口只有一个方法，那么就可以称为函数时接口，在java 8之前很容易通过匿名内部类来实现。在java 8中将匿名内部类转成Lambda 表达式也是很简单的，只需要多练习几次就很容易掌握。
关于方法引用可能就比较难以理解。简单来说就是返回值和方法参数一致，就可以用方法引用，具体细节参考下面的例子。
import java.util.*;
interface Callable { // [1]
void call(String s);
}
class Describe {
void show(String msg) { // [2]
System.out.println(msg);
}
}
public class MethodReferences {
static void hello(String name) { // [3]
System.out.println("Hello, " + name);
}
static class Description {
String about;
Description(String desc) { about = desc; }
void help(String msg) { // [4]
System.out.println(about + " " + msg);
}
}
static class Helper {
static void assist(String msg) { // [5]
System.out.println(msg);
}
}
public static void main(String[] args) {
Describe d = new Describe();
Callable c = d::show; // [6]
c.call("call()"); // [7]
c = MethodReferences::hello; // [8]
c.call("Bob");
c = new Description("valuable")::help; // [9]
c.call("information");
c = Helper::assist; // [10]
c.call("Help!");
}
}[1] 我们从单一方法接口开始（同样，你很快就会了解到这一点的重要性）。
[2] show() 的签名（参数类型和返回类型）符合 Callable 的 call() 的签名。
[3] hello() 也符合 call() 的签名。
[4] help() 也符合，它是静态内部类中的非静态方法。
[5] assist() 是静态内部类中的静态方法。
[6] 我们将 Describe 对象的方法引用赋值给 Callable ，它没有 show() 方法，而是 call() 方法。 但是，Java 似乎接受用这个看似奇怪的赋值，因为方法引用符合 Callable 的 call() 方法的签名。
[7] 我们现在可以通过调用 call() 来调用 show()，因为 Java 将 call() 映射到 show()。
[8] 这是一个静态方法引用。
[9] 这是 [6] 的另一个版本：对已实例化对象的方法的引用，有时称为绑定方法引用。
[10] 最后，获取静态内部类的方法引用的操作与 [8] 中外部类方式一样。
上面提到了绑定方法引用，那么对应的还有未绑定方法引用。下面是一个例子
class X {
String f() { return "X::f()"; }
}
interface MakeString {
String make();
}
interface TransformX {
String transform(X x);
}
public class UnboundMethodReference {
public static void main(String[] args) {
// MakeString ms = X::f; // [1]
TransformX sp = X::f;
X x = new X();
System.out.println(sp.transform(x)); // [2]
System.out.println(x.f()); // 同等效果
}
}我们已经知道了与接口方法同名的方法引用。 在 [1]，我们尝试把 X 的 f() 方法引用赋值给 MakeString。结果：即使 make() 与 f() 具有相同的签名，编译也会报“invalid method reference”（无效方法引用）错误。 这是因为实际上还有另一个隐藏的参数：this。 你不能在没有 X 对象的前提下调用 f()。 因此，X :: f 表示未绑定的方法引用，因为它尚未“绑定”到对象。
要解决这个问题，我们需要一个 X 对象，所以我们的接口实际上需要一个额外的参数的接口，如上例中的 TransformX。 如果将 X :: f 赋值给 TransformX，这在 Java 中是允许的。这次我们需要调整下心里预期——使用未绑定的引用时，函数方法的签名（接口中的单个方法）不再与方法引用的签名完全匹配。 理由是：你需要一个对象来调用方法。
[2] 的结果有点像脑筋急转弯。 我接受未绑定的引用并对其调用 transform()，将其传递给 X，并以某种方式导致对 x.f() 的调用。 Java 知道它必须采用第一个参数，这实际上就是 this，并在其上调用方法。
本文参考 on java 8