java的final关键字与闭包

前面一篇文章曾经有提到过java中闭包的实现，其实当时比较的粗糙，所以一直觉得有必要要把这部分搞的比较明白才行。。。

首先先从java的final关键字说起：

（1）final的方法，这个方法不能被改变，不能被重载

（2）final的类，这个类型不能被继承

（3）final的数据，该数据域是不能被改变的。。。

对于第三种，可能会引起一些误会，但是误会归误会，它始终是正确的。。。

要讲清楚这个就要从数据类型来说其了：

（1）在java中数据都是以对象的形式存在的，而且持有的只是该对象的引用，指向对象实际的存储区域

（2）基本数据类型则是直接保存在堆栈中的，没有引用的概念（基本数据类型都有自己的包装器类型，与（1）是一样的）

我们以两行代码来具体说明：

		int a = 1;
		Object b = new Object();

当程序运行到这部分的时候，对于我们来说，我们可以认为当前程序已经有了两个变量了，a和b，然而对于实际的计算机它不这么认为，再它看来它知道了有 两个内存区域分别存储的是什么。。。(这里内存是指当前的运行栈)

首先变量a对计算机来说代表一段内存区域，其中保存的是一个整形的值

对于变量b，对于计算机来说它也代表一段内存区域，但是它里面存的是一个引用，用于指向另一块内存区域，也就是对象实际的存储区域。。。

如下图：

这个时候如果我们修改变量a，那么就相当于修改a所表示的内存中的值，

如果我们对于b，调用其的一些set之类的方法，b本身所代表的内存值并没有变，变的是它所指向的另一块内存中的对象的值。。。

如果我们将这两个变量都用final关键字进行修饰，如下：

                final int a = 1;
		final Object b = new Object();

那么就代表a和b所指代的那段内存区域的值不能被修改了。。。那么表现就是a那个int类型的值不能修改了，b变量不能再指向其余的对象了。。。例如

b = new Object();

这样子会报错，但是依然可以调用b的set一类的方法来修改它所指的对象的值。。。（这就是容易误解的地方，以为final修饰引用就没什么用）

接下来来说说java中的闭包：

在java中闭包一般通过内部类对象来实现，因为内部类对象有比较有意思的特性，那就是可以访问所属的外部类对象的所有方法，但是当内部类对象在外部类对象的某一个方法中定义的时候，那么可以访问当前方法中用final关键字修饰的局部变量，例子如下：

package Time;

import java.util.ArrayList;
import java.util.List;

public class ThreadTest {
	public static void main(String args[]) throws InterruptedException {
		final List<String> list = new ArrayList<String>();
		
		Thread t = new Thread(new Runnable(){
			private List<String> now = list;
			@Override
			public void run() {
				// TODO Auto-generated method stub
				list.add("aaa");
				System.out.println(now.get(0));
			}
			
		});
		t.start();
		t.join();
	}
}

嗯，看起来还真是像闭包那么回事了。。也还算挺好用的。。。。例如可以将以前写的一个netty的handler改写成下面的方式：

    public void channelActive(final ChannelHandlerContext ctx) throws Exception {
        
        ctx.pipeline().write(new UnixTime());
		ctx.pipeline().write(new UnixTime());
		ctx.pipeline().write(new UnixTime());
        ctx.pipeline().write(new UnixTime()).channel().pipeline().flush().addListener(new ChannelFutureListener(){

			@Override
			public void operationComplete(ChannelFuture future)
					throws Exception {
				// TODO Auto-generated method stub
				//future.channel().pipeline().close();
				ctx.pipeline().close();
			}
        	
        });
         
        

    }

这里直接调用的是外面的ctx变量。。。用起来还真有那一点像node.js的味道。。。

这么看的话，java的异步回调其实也能比较好的实现。。。不过这里需要考虑的是在多线程情况下的一些并发访问问题。。。但是如果能够按照netty的方式，让变量尽量满足线程封闭（java并发变成实战）的条件，也就没有什么问题了。。。