Java7决定包含闭包

[微创社（MCC）]

好消息

[ghy_5536]

大哥大姐们，看看我的帖子好吗，我遇到难题了。。。
就这下面这个帖子

为什么getHibernateTemplate().update执行的是插入操作，而不是更新操作

谢谢了！我刚学SSH。。。

[火龙果被占用了]

Java 社区天天在变，前段时间还说到 JDK 7 不会支持闭包了，现在又说要支持了，估计再过几个月又有可能不支持了。

就算支持闭包了，也不见得是好事，在语言层次上只会把 Java 弄得越来越复杂，像 JavaScript 中那些稀奇古怪的语法特性，再者 JavaScript 中的闭包有谁敢说自己是精通的？

[cgstrikezyl]

大哥大姐们，看看我的帖子好吗，我遇到难题了。。。
就这下面这个帖子

为什么getHibernateTemplate().update执行的是插入操作，而不是更新操作

谢谢了！我刚学SSH。。。
看你ID的生成方式

[kicen0629]

我对于闭包的问题了解不是很深，对于其中的运行机制很不了解，请大家帮忙

我看到一个JavaScript程序写的闭包：
function fun1(){
var num = 0;
var fun2 = function(){
alert(num);
};
num++;
return fun2;
}
var n = fun1();
n();
alert(n.toString());
这样运行出的结果是1，而不是0。
其中的解释是 闭包有两个特点：
1、作为一个函数变量的一个引用 - 当函数返回时，其处于激活状态。
2、一个闭包就是当一个函数返回时，一个没有释放资源的栈区。
这样就可以解释出现的结果是1的问题了。

我自己用java写了一个类似的，但不是说java不支持闭包吗，但是我运行的结果也是这样的
public interface Add {
public void add(String a);
}

public class Test {
public String a = "a";
public Add gg(){
Add add = new Add(){
public void add(String b){
b = a;
System.out.println("----"+b);
}
};
a = a+"a";
return add;
}

public static void main(String[] args){
Test t = new Test();
System.out.println("t.i=="+t.a);
Add a = t.gg();
System.out.println("t.i=="+t.a);

a.add("sss");
System.out.println();
}

}

这样运行的结果是：
t.i==a
t.i==aa
----aa
这样是不是也可以说明我这样在java中写闭包是可以的呢？我这样写诗闭包吗？
请大家帮忙解释一下。
另外能不能用简单的话描述一下什么是闭包？
谢谢！

[临碣]

无聊的特征,降低java的封装特性,向过程语言靠拢.

那个特性我一直认为是因为对封装实现不完整而遗留的尾巴.现在搞得跟什么新东西一样,还要拿出来特意实现.这个时代真的看不懂了.

虽然多年前就发现面向对象并没有面向过程的语言灵活,且在设计上容易陷入死结.选择了面向对象,尤其当年java还选择了面向对象的简单版,说什么多继承之类的破坏面向对象特征,而现在又要向回看.真是无聊的事情啊.

是不是java8要支持内嵌汇编指令啊?

[微创社（MCC）]

@bao110908、zcl198715、eastoneking

主题：JAVA 需要引入闭包吗
http://www.javaeye.com/topic/406229

上面这个贴子会帮你理解:
[1]什么是闭包
[2]为什么要有闭包
[3]闭包有什么作用
[4]闭包的替代方案
[5]闭包的副作用
[6]Java为什么没有闭包
[7]Java的代算

其实Java比之C#越来越弱，
表面上看是少了一些语言特性，
其实根本就是少了一个“闭包”。

“闭包”是非常基础的语言特征，
在OO的前提下，闭包带来的优势远远大于其“实现”上的复杂性。

[panhaichun]

[Quote=引用 6 楼 zcl198715 的回复:]
引用楼主 pcnetman888 的回复:
好消息

闭包对java有那么重要吗？
[/Quote]

就是

[微创社（MCC）]

由于java没有实现闭包，我给一个C#的例子，
即便是语法层面上，闭包带来的好处就是简洁，
而不是复杂。（复杂是提供商的事情，对使用者来说正好相反）


[1]没用闭包的场景

using System;
using System.Collections.Generic;

//工具类,其作为是通过"断言"来筛选元素
static class ListUtil
{
    public static IList<T> Filter<T>(IList<T> source, Predicate<T> predicate)
    {
        List<T> ret = new List<T>();
        foreach (T item in source)
        {
            if (predicate(item))
            {
                ret.Add(item);
            }
        }
        return ret;
    }
}

//测试类
class Test
{
    static void Main()
    {
        Console.Write("Maximum length of string to include? ");
        int maxLength = int.Parse(Console.ReadLine());

        //===============区别部分==================
        VariableLengthMatcher matcher = new VariableLengthMatcher(maxLength);
        Predicate<string> predicate = new Predicate<string>(matcher.Match);
        //===============区别部分==================

        string[] words = { "111111111", "222", "33" };
        IList<string> shortWords = ListUtil.Filter(words, predicate);
    }
}

// 如果没有闭包,需要增加以下的类(匿名可以缓解这个情况,不过只能在简单场景下,C#1x没有JAVA有)
public class VariableLengthMatcher
{
    int maxLength;

    public VariableLengthMatcher(int maxLength)
    {
        this.maxLength = maxLength;
    }

    /// <summary>
    /// Method used as the action of the delegate
    /// </summary>
    public bool Match(string item)
    {
        return item.Length <= maxLength;
    }
}

[2]使用闭包的场景

using System;
using System.Collections.Generic; //工具类,其作为是通过"断言"来筛选元素

static class ListUtil
{
    public static IList<T> Filter<T>(IList<T> source, Predicate<T> predicate)
    {
        List<T> ret = new List<T>();
        foreach (T item in source)
        {
            if (predicate(item))
            {
                ret.Add(item);
            }
        } return ret;
    }
} //测试类 

class Test
{
    static void Main()
    {
        Console.Write("Maximum length of string to include? "); 
        int maxLength = int.Parse(Console.ReadLine());
        //===============区别部分================== 
        //由于通过闭包,直接使用到上下文,一句话替代了整个VariableLengthMatcher类  
        Predicate<string> predicate = delegate(string item){return item.Length <= maxLength;};
        //===============区别部分==================  
        string[] words = { "111111111", "222", "33" };
        IList<string> shortWords = ListUtil.Filter(words, predicate);
    }
}

[微创社（MCC）]

@eastoneking
[Quote=引用 11 楼 eastoneking 的回复:]
是不是java8要支持内嵌汇编指令啊?
[/Quote]

BTW：
支持内嵌汇编指令本来就是可以的.

虚拟机层面上都可以，包括.net
只不过实现上复杂了点。

[panhaichun]

Quote=引用 14 楼 pcnetman888 的回复:]
由于java没有实现闭包，我给一个C#的例子，
即便是语法层面上，闭包带来的好处就是简洁，
而不是复杂。（复杂是提供商的事情，对使用者来说正好相反）


[1]没用闭包的场景
C# codeusing System;using System.Collections.Generic;//工具类,其作为是通过"断言"来筛选元素staticclass ListUtil
..........
[/Quote]

java中的闭包早就见过了

如：

getHibernateTemplate().execute(new HibernateCallback() {
    public Object doInHibernate(Session session) throws HibernateException, SQLException {
     //据说这就是闭包。。。。
});
[code=Java]

引用楼上的例子大致就是这样子
[code=Java]
interface Predicate{
    boolean predicate(String item);
}

IList<string> shortWords = ListUtil.Filter(words, new Predicate {
int maxLength = ......;
boolean predicate(String item) {
return item.length <= maxLength}
});

可能就是把这种写法弄个简单的语法支持吧

[panhaichun]

[Quote=引用 14 楼 pcnetman888 的回复:]
由于java没有实现闭包，我给一个C#的例子，
即便是语法层面上，闭包带来的好处就是简洁，
而不是复杂。（复杂是提供商的事情，对使用者来说正好相反）

[1]没用闭包的场景
C# codeusing System;using System.Collections.Generic;//工具类,其作为是通过"断言"来筛选元素staticclass ListUtil
..........
[/Quote]



java中的闭包早就见过了

如：
Java code
getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException, SQLException {
//据说这就是闭包。。。。
}
});
[code=Java]

引用楼上的例子大致就是这样子
[code=Java]
interface Predicate{
boolean predicate(String item);
}

IList<string> shortWords = ListUtil.Filter(words, new Predicate {
int maxLength = ......;
boolean predicate(String item) {
return item.length <= maxLength;
}
});



可能就是把这种写法弄个简单的语法支持吧

[微创社（MCC）]

@panhaichun

你举的例子是匿名,并非闭包,
java到目前为止还没有实现哪怕是最基础性的闭包.
也就是函数是一阶值.

匿名不是闭包,
只不过闭包经常发生在匿名函数中.
匿名函数是个没有指针(引用)指向的函数.
闭包是语言的一种基础特性.

在java中,使用内部类+匿名,可以最接近闭包.

[panhaichun]

[Quote=引用 18 楼 pcnetman888 的回复:]
@panhaichun

你举的例子是匿名,并非闭包,
java到目前为止还没有实现哪怕是最基础性的闭包.
也就是函数是一阶值.

匿名不是闭包,
只不过闭包经常发生在匿名函数中.
匿名函数是个没有指针(引用)指向的函数.
闭包是语言的一种基础特性.

在java中,使用内部类+匿名,可以最接近闭包.
[/Quote]

我知道那是匿名类，这不是一种实现闭包方式么？？？，从概念上讲可能不是闭包，功能到了就行。

整个世界都在搞概念，放到C语言中其实就是个函数指针。

[微创社（MCC）]

[Quote=引用 19 楼 panhaichun 的回复:]
我知道那是匿名类，这不是一种实现闭包方式么？？？，从概念上讲可能不是闭包，功能到了就行。
[/Quote]
这段话还有点道理,
你所指的所谓的"java7之前的闭包"确有这样的提法:

所见如下:
《C#和Java的闭包－Jon谈《The Beauty of Closures》》
http://www.cnblogs.com/Klesh/archive/2008/05/15/The-Beauty-of-Closures.html

---------------------------------

[Quote=引用 19 楼 panhaichun 的回复:]
整个世界都在搞概念，放到C语言中其实就是个函数指针。
[/Quote]
这句话就没啥道理了，可以说是逻辑上的重大错误。
至于到底是不是“概念”，建议看一看以下这个文章：

所见如下:
《Java 理论与实践: 闭包之争》
http://www.ibm.com/developerworks/cn/java/j-jtp04247.html

---------------------------------

知之为知之，不知为不知，乱说就没意思了。。。

[微创社（MCC）]

摘录几个小段：

匿名内部类只是宽泛地近似于闭包，
它们并没有深入到您需要的程度。

匿名类就像是满满一桶冰水，
每次用的时候都会洒到您的腿上。
多余句子结构所需的过多的额外处理阻碍了对匿名类的使用。
您迟早会放弃。

当语言结构既麻烦又不好用时，人们自然不会用它。
缺乏能够有效使用匿名内部类的 Java 库使问题更为明显。
要想使闭包在 Java 语言中实践并流行起来，它必须要敏捷干净。

过去，闭包绝不是 Java 开发人员优先考虑的事情。
在早期，Java 设计人员并不支持闭包，
因为 Java 用户对无需显式完成 new 操作就在堆上自动分配变量心存芥蒂。

如今，围绕是否将闭包纳入到基本语言中存在极大的争议。
最近几年来，
动态语言（如 Ruby、JavaScript，甚至于 Lisp ）的流行让将闭包纳入 Java 语言的支持之声日益高涨。
从目前来看，Java 1.7 最终很可能会采纳闭包。只要不断跨越边界，总会好事连连。

闭包是可以用作函数参数和方法参数的代码块。
一直以来，这种编程结构都是一些语言（如 Lisp、Smalltalk 和 Haskell）的重要组成部分。
尽管一些颇具竞争力的语言（如 C#）采纳了闭包，但 Java 社区至今仍抵制对它的使用。

关于闭包这个问题，Java 爱好者们现在陷入了类似的争论中。
一些人认为闭包带给编程语言的额外复杂性并不划算。
他们的论点是：为了闭包带来的一点点便利而打破原有语法糖的简洁性非常不值得。
其他一些人则认为闭包将引发新一轮模式设计的潮流。
要得到这个问题的最佳答案，您需要跨越边界，去了解程序员在其他语言中是如何使用闭包的。

[微创社（MCC）]

JAVA社区最希待的语言特征

闭包 47.4% (734 Votes)
具体 17.2% (266 Votes)
第一类属性 10.4% (162 Votes)
操作符重载 4.3% (67 Votes)
BigDecimal语法 3.4% (54 Votes)
JSR-295 Bean绑定 7.3% (113 Votes)

关于闭包的讨论补充如下：
http://www.infoq.com/cn/news/2009/01/java7-updated

比较极端的提法：
Ricky Clarkson认为没有闭包Java将灭亡
http://rickyclarkson.blogspot.com/2008/12/java-just-died-no-closures-in-java-7.html

[wmdtksmld]

讨论很激烈啊

[哈库纳玛塔塔]

[Quote=引用 19 楼 panhaichun 的回复:]
引用 18 楼 pcnetman888 的回复:
@panhaichun

整个世界都在搞概念，放到C语言中其实就是个函数指针。
[/Quote]

顶你一个，的确。整个世界都在搞概念。
ORM，说白了就是以前的结果集。 只不过这个结果集以普通的类来提供。
还有spring一大堆新功能高级特性，说到最后就是一个 AOP和IOC外加一个Propxy

[哈库纳玛塔塔]

我出了一个框架叫more。 最大本质就是Filter、AOP、IOC、Propxy。
例如我more框架中submit2.0提供了一个叫页面预处理的功能。

说白了工作原理跟jsp:include一样。只不过包含的代码是action代码而已。
这就是一个全新的概念 我就叫它 页面预处理。

在jsp、asp、php 中都是include

在struts中就是一些视图标签（有关struts可能说的不够精确）。

[微创社（MCC）]

http://developer.51cto.com/art/200912/166224.htm

大辩论：Java不是C++ 闭包让Java更简单