内部类与函数式编程
首先,我们来看下策略模式,这是网上找到的一个关于策略模式的解释:策略模式是对算法的包装,是把使用算法的责任和算法本身分割开来,委派给不同的对象管理。策略模式通常把一个系列的算法包装到一系列的策略类里面,作为一个抽象策略类的子类。用一句话来说,就是:“准备一组算法,并将每一个算法封装起来,使得它们可以互换”。
这里不详细介绍策略模式,只是简单的用策略模式来引入函数式编程的例子。
通常,传递给方法的数据不同,结果不同。如果我们希望方法在调用时行为不同,该怎么做呢?结论是:只要能将代码传递给方法,我们就可以控制它的行为。
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