/*
	局部内部类
		A:可以直接访问外部类的成员
		B:在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
	
	面试题：
		局部内部类访问局部变量的注意事项?
		A:局部内部类访问局部变量必须用final修饰
		B:为什么呢?
			局部变量是随着方法的调用而调用，随着调用完毕而消失。
			而堆内存的内容并不会立即消失。所以，我们加final修饰。
			加入final修饰后，这个变量就成了常量。既然是常量。你消失了。
			我在内存中存储的是数据20，所以，我还是有数据在使用。
*/
class Outer {
	private int num  = 10;
	
	public void method() {
		//int num2 = 20;
		//final int num2 = 20;
		class Inner {
			public void show() {
				System.out.println(num);
				//从内部类中访问本地变量num2; 需要被声明为最终类型
				System.out.println(num2);//20
			}
		}
		
		//System.out.println(num2);
		
		Inner i = new Inner();
		i.show();
	}
}

class InnerClassDemo5 {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}

/*
	局部内部类:
		A:可以直接访问外部类的成员
		B:在局部位置,可以创建内部类对象,通过对象调用内部类方法,来使用局部内部类功能。
	
	面试题:
		局部内部类访问局部变量的注意事项
		A:局部内部类访问局部变量必须用final修饰
		B:为什么呢?
			因为局部变量会随着方法的调用而调用,随着调用完毕而消失。
			而堆内存的内容并不会立即消失。所以,我们加final修饰
			加入final修饰后,这个这变量就成了常量。既然是常量。你消失了。
			我在内存中存储的是数据20,所以,我还是有数据在使用。
*/
package cn.Inner5;

class Outer{
	private int num = 10;
	
	
	
	public void method(){
		//int num2 = 20;
		final int num2 = 20;
		
		class Inner{
			public void show(){
				System.out.println(num);
				//从内部类中访问局部变量 num2；需要被声明为最终类型
				//System.out.println(num2);//20
			}
		}
		//System.out.println(num2);
		
		Inner i = new Inner();
		i.show();
	}
}

class InnerClassDemo5{
	public static void main(String[] args){
		Outer o = new Outer();
		o.method();
	}
}

* 局部内部类访问局部变量必须用final修饰
* 局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
 因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用
 
1.8之前的版本是需要加final，1.8之后不用加也可以使用。
 
public class Demo2_InnerClass {
    public static void main(String[]args){
        Outher o=new Outher();
        o.method();
    }
}

class Outher{
    public void method(){
        int num=10;
        class Inner{
            public void print(){
                System.out.println("局部内部类成员方法");
                System.out.println("访问局部变量需要设置为final:"+num);
            }
        }
        Inner i=new Inner();//在方法中创建Inner对象
        i.print();
    }
   /* public void run(){//局部内部类，只能在其所在的方法中访问
        Inner i=new Inner();
        i.print();
    }*/
}
 
 

我们都知道方法中的匿名/局部内部类是能够访问同一个方法中的局部变量的，但是为什么局部变量要加上一个final呢？ 
 
首先我们来研究一下变量生命周期的问题，局部变量的生命周期是当该方法被调用时在栈中被创建，当方法调用结束时（执行完毕），退栈，这些局部变量就会死亡。但是内部类对象是创建在堆中的，其生命周期跟其它类一样，只有当jvm用可达性分析法发现这个对象通过GCRoots节点已经不可达，然后进行gc才会死亡。
 
所以完全有可能存在的一个现象就是一个方法已经调用结束（局部变量已死亡），但该内部类的对象仍然活着，也就是说内部类创建的对象的生命期会超过局部变量，这就会出现内部类的对象要访问局部变量时访问失败，而java为了保证这种情况不会发生，就用了一种折中的方案：内部类要访问局部变量，局部变量必须加final，那为什么局部变量定义成final就可以了呢？
 
然后我们再来看final这个关键字修饰变量的特点：当final修饰一个基本数据类型的变量时，这个基本类型的变量在初始化的时候就应该赋值，并且初始化完成之后其值就不能再发生改变了；当final修饰一个引用类型的变量时，这个引用类型的变量在初始化的时候就应该赋值并且之后不能再发生改变，但是引用类型的变量指向的对象的堆内存的值是可以改变的。
 
基于final修饰变量的以上两个特点，java就把局部内部类对象要访问的final型局部变量，复制过来变成该内部类对象中的一个成员变量，这样即使栈中局部变量（含final）已死亡，但由于它是final的，其值是不会发生改变的，因而内部类对象在局部变量死亡后，照样可以访问自己内部维护的一个值跟局部变量一样的成员变量，从而解决这个问题。
 
ps:java8中匿名/局部内部类访问局部变量时，局部变量已经可以不用加final了，但其实这个局部变量还是final的，只不过不用显式的加上而已，推测可能是编译机制发生了改变。