再论闭包

--再论闭包 --

下面这个例子 引自 《Groovy in action》 第五章。

一段 Java 代码，

interface ResourceUser {
    void use(Resource resource)
}
resourceHandler.handle(new ResourceUser(){
    public void use (Resource resource) {
        resource.doSomething()
    }
});

下面是一段等价 Groovy 的代码。

resourceHandler.handle { resource -> resource.doSomething() }

惊叹吧 ？  8行JAVA代码居然被 Groovy 如此 easy 地实现了。

惊叹！ 惊叹之余再来反思。。。

(1)，为何能如此简单（Groovy）：因为它在使用闭包。

        Groovy中 行为元素（函数，过程）作为一级元素。

        像resource -> resource.doSomething() 就是一个匿名函数。

        参数 为 resource，返回值 为 resource.doSomething()。

(2)，为何如此复杂（Java）：因为它在模拟闭包。

        函数咱没有，那就包装一下，模拟一下，但好像臃肿了点。。

(3)，易理解吗？

       Groovy ：资源处理器 （名词：resourceHandler）处理 （动词：handle）一个函数 （匿名函数：resource ->  

                      resource.doSomething()）。

       模拟闭包的Java ：资源处理器 （名词：resourceHandler）处理 （动词：handle）一个资源用户 （名词：new

                      ResourceUser(){...}）。

       资源处理器应该只处理资源啊。。。

(4)， 重新造句 （Java）

       OO的Java ：资源处理器 （名词：resourceHandler）处理 （动词：handle）一个资源 （名词：resource）。

new ResourceHandler(){
	protected void handle(Resource resource){
		//doSomething ....
		resource.doSomething();
		//doSomething ....
	}
}.handle(request);

个人观点 ：

一种功能如果可以用FP中的闭包来实现，

那它必然也可以用OO中的对象来实现， 而且更贴近于人的思维。

有必要用对象模拟闭包吗？个人感觉没必要，

用对象模拟的闭包 来实现一种功能，感觉相比上诉两种情况更复杂。

public class Closure{
		public void anotherDoSomething(){
				System.out.println("another closure...");
			};
		
		public static void main(String[] anrgs){
				new Closure(){
						protected void innerDoSomething(){
							System.out.println("closure..");
						}
					}.innerDoSomething();
					
				new Closure().anotherDoSomething();	
			}
	}

new ResourceHandler(){
	protected void handle(Resource resource){
		//doSomething ....
		resource.doSomething();
		//doSomething ....
	}
}.handle(request);

 这种方式跟匿名内部类还是有区别的。

public class Closure{
		public void anotherDoSomething(){
				System.out.println("another closure...");
			};
		
		public static void main(String[] anrgs){
				new Closure(){
						protected void innerDoSomething(){
							System.out.println("closure..");
						}
					}.innerDoSomething();
					
				new Closure().anotherDoSomething();	
			}
	}

new ResourceHandler(){
	protected void handle(Resource resource){
		//doSomething ....
		resource.doSomething();
		//doSomething ....
	}
}.handle(request);

下面的代码确实有匿名内部类，

但匿名内部类不一定就是模拟闭包，

他也可以 提供 一种更简洁的覆盖方式，

不用匿名内部类也可以实现：

class ConcreteResourceHandler extends ResourceHandler{
	protected void handle(Resource resource){
		//doSomething ....
		resource.doSomething();
		//doSomething ....
	}
}
......
new ConcreteResourceHandler().handle(request);