关于java实现闭包的可行性分析.改

受ruby影响昨天一时狗血写了这个东西
http://topic.csdn.net/u/20081114/20/1102ede3-ec28-494b-a78e-9b61bc8477ec.html睡觉前想了下发现误很大 心想丢人丢大了 于是大早起来更新了代码 特此重发例行声明：本文仅为技术探讨，并无实际价值 ，不喜请点右上红叉。分外java风格和FP风格两种实现java风格实现：---------------------------ClassicClosure -------------------------------
package org.shadowingfly.closure;
//模拟函数 假设函数的形参与本地变量（local variable）均以其实现类的field表示
//形参在实例化函数后传值 而本地变量在对象构造时初始化
//待改进 目前仅为简单模拟
public interface ClassicClosure {
Object launch();
   
}
------------------------外部函数COuntFunc----------------------------
package org.shadowingfly.closure;public class COuntFunc implements ClassicClosure {
    private String fp;//形参fp
    private String cmd;//形参 cmd
    private ClassicClosure innerFunc = new ClassicClosure()//内部函数 innerFunc
    {
        //内部函数本体
        public Object launch() {
           
            System.out.println("welcome to " + fp);//访问外围执行堆栈形成闭包
            return null;
        }
       
    };    public String getCmd() {
        return cmd;
    }
    public void setCmd(String cmd) {
        this.cmd = cmd;
    }
    public String getFp() {
        return fp;
    }
    public void setFp(String fp) {
        this.fp = fp;
    }   //外围函数本体 返回闭包函数
    public Object launch() {
        System.out.println("bye bye " + cmd);
       
        return innerFunc;
    }
   }
---------------TestClassic测试用例----------------------
package org.shadowingfly.closure;public class TestClassic {
public static void main(String[] a)
{
    COuntFunc out = new COuntFunc();//实例外围函数
    out.setCmd("command");//形参传值
    out.setFp("function programming");
    ClassicClosure inner = ( ClassicClosure)out.launch();//执行外围函数 返回闭包函数
    out = null;//假设释放堆栈
    // inner.launch();
    out = new COuntFunc();//实例化同一外围函数
    out.setCmd("cmd");//传入不同值的形参
    out.setFp("fp");
    ClassicClosure inner2 = ( ClassicClosure)out.launch();//返回外围执行环境不同的同一闭包函数
    out = null;
    inner.launch();//分别执行动态创建的闭包函数
    inner2.launch();
}
}
--------------------------------------------------------------------------------
优点：java原生语法实现，代码简单易读，且执行效率上有明显优势。
缺点：依赖于内部类，语言层面不支持函数指针，故对于复杂的嵌套，同一内部函数多次嵌套，多层嵌套等力不从心。
FP风格实现：第二种实现：使用函数式编程风格，通过模板类维护一个scope链实现堆栈闭包。 代码如下
Function类代码比较繁琐且与具体应用无关使用的时候只需复制即可，就懒得注释了，有兴趣的可以自己研究。
------------------- Function模板类----------------------
package org.shadowingfly.closure;import java.lang.reflect.Field;
import java.util.LinkedList;
import java.util.List;public abstract class Function implements Cloneable{
public LinkedList<Function> scope;
public Function()
{
   
   
        scope = new LinkedList<Function>();
        this.scope.add(this);
       
}
public void init() throws Exception
{
    Field[] fields = this.getClass().getDeclaredFields();
    for(Field field:fields)
    {
       
    if(((Class)field.getGenericType()).isAssignableFrom(Function.class))
    {
        field.setAccessible(true);
        Function sub = (Function) field.get(this);
        //System.out.println(sub);
       
        sub.scope.addFirst((Function)this.clone());
   
    }
    }   
}public Object getValue(String name) throws Exception
{
   
    for(Function func:scope)
    {
   
    Field[] fields = func.getClass().getDeclaredFields();
    for(Field field:fields)
    {
        if(field.getName().equals(name))
        {
            field.setAccessible(true);
            return field.get(func);
        }
    }
    }   
   
    return null;
}
public void setValue(String name,Object value)throws Exception
{
    for(Function func:scope)
    {
    Field[] fields = func.getClass().getDeclaredFields();
    for(Field field:fields)
    {
        if(field.getName().equals(name))
        {
            field.setAccessible(true);
             field.set(func,value);
        }
    }
    }
   
}
public Object launch()
{
    try {
        this.init();
    } catch (Exception e) {
       
        e.printStackTrace();
    }
   return null;
}}
-----------------------------OutFunc-------------------------------------
package org.shadowingfly.closure;
//外部函数抽象 假设形参与本地变量均作为field存在 且形参在执行前后传值 本地变量在构造时初始化
public class OutFunc extends Function{
    private String fp ;//形参fp
    private String cmd ;//形参cmd
    public Function inner = new InnerFunc();//内部函数 inner
   
//外围函数本体 根据形参输出语句 并返回闭包函数
public Object launch()
{
    super.launch();//执行默认动作
    System.out.println("byebye "+cmd);
   
   
    return inner;
}
   }
-----------------------InnerFunc------------------------------
package org.shadowingfly.closure;
//内部函数抽象
public class InnerFunc extends Function{
    //内部函数本体 访问外围执行堆栈的变量fp 并打印语句
    public Object launch()
    {  
        super.launch();//执行默认动作
       try {
        System.out.println("welcome to "+getValue("fp"));
    } catch (Exception e) {
       
        e.printStackTrace();
    }
        return null;
    }}
--------------- Test测试用例--------------
package org.shadowingfly.closure;
import org.shadowingfly.closure.Function;
import org.shadowingfly.closure.OutFunc;
public class Test {   
    public static void main(String[] args) throws Exception {
        OutFunc out = new OutFunc();//实例化外部函数
       
       
        out.setValue("cmd", "command");//形参赋值
        out.setValue("fp", "function programming");
        Function inner = (Function)out.launch();//执行外部函数 并返回闭包
        out = null;//假设释放外围堆栈
        out = new OutFunc();//新实例化同一外部函数
        out.setValue("cmd", "cmd");//传入不同形参
        out.setValue("fp", "fp");
        Function inner2 = (Function)out.launch();//返回不同执行堆栈的闭包
        out = null;
        inner.launch();//启动闭包函数1
        inner2.launch();//启动闭包函数2
       
    }}
-----------------------------------------------------------
优点：风格上更接近函数式编程，对于多层嵌套，复杂嵌套，循环嵌套提供较好的支持。
缺点：使用基类维护的scope链保存堆栈，代码侵入比较严重（如对外部堆栈变量的访问需使用getvalue（）方法）且执行效率不高。