1.首先来了解一下局部内部类是如何访问局部变量的

Person类是外部类，LoInClassIntf是接口，localInClassRe是Person类的成员方法，且返回值类型为LoInClassIntf；

方法内定义了一个局部内部类LoInnerClass，该内部类实现了接口LoInClassIntf；

方法内还定义了一个final的局部变量a，定义了一个LoInnerClass类型的对象引用loInC；

代码如下：

 1     //笔记23：内部类--局部内部类--实现接口，返回内部类对象
 2     //接口
 3     public interface LoInClassIntf {
 4         void test();
 5     }
 6 
 7     //方法localInClassRe，返回值为LoInClassIntf，局部内部类来实现该接口，向上转型
 8     public LoInClassIntf localInClassRe() {  
 9         final int a = 1; //常量
10         
11         //笔记23--内部类--局部内部类--实现接口
12         class LoInnerClass implements LoInClassIntf {
13             public void test() {
14                 System.out.println("variable a:" + a);
15             }
16         }
17 
18         LoInnerClass loInC = new LoInnerClass();
19         return loInC;
20     }
21 
22     public static void main(String[] args) {
23         //笔记23--局部内部类
24         Person per = new Person();
25         
26         LoInClassIntf lInCIntf = per.localInClassRe();
27         lInCIntf.test();
28     }

输出结果为：

1 variable a:1

成员方法localInClassRe执行中的内存示意图如下：

成员方法localInClassRe执行后的内存示意图如下：

分析：

    成员方法localInClassRe执行后，方法体中的局部变量a和对象引用loInC都被释放掉了，但分配在堆中的对象未回收，这时由main方法中的局部变量lInCIntf来指向它；

    到这里还没什么问题，但第27行，lInCIntf调用了test方法，test方法中访问到了成员方法localInClassRe中的局部变量a，而a此时已不存在了，所以就会出现错误；

    即，局部变量与局部内部类的对象的生命周期不同；

    为解决这一问题，Java把局部内部类要访问的局部变量重新拷贝了一份，并把备份放在内部类的常量池中，这样不论方法有没有执行结束，拷贝都是存在的，就不会再出现访问不存在的变量的错误了。

成员方法localInClassRe执行中的内存示意图如下：

成员方法localInClassRe执行后的内存示意图如下：

 上面涉及到的局部变量a是方法体内定义的，如果局部内部类访问的是方法体的参数呢？

Java采取的方法是，默认为局部内部类的构造方法传入该参数作为构造方法的参数，然后用该参数来初始化内部类中拷贝的变量a。

局部内部类如何访问局部变量的问题解决了，那么为什么只能访问final的局部变量呢？

2.数据同步的问题

上面通过拷贝一份局部变量来解决生命周期不同的问题，如果方法体和局部内部类都改变了a的值会怎么样呢？

如下图所示：

这样两个a不一致，就会出现数据不同步，下一步应该用a=2还是a=3呢？

为解决这个问题，Java规定局部内部类可访问的局部变量必须为final的，即内部类不能改变要访问的局部变量的值，这样就不会出现数据不同步的问题了

原文转载自: http://www.cnblogs.com/chanchan/p/8402411.html 

内部类概念

一个类中包含另外一个类。

分类

1. 成员内部类。
2. 局部内部类(包含匿名内部类)。

成员内部类

定义格式：

修饰符 class 类名称 {
    修饰符 class 类名称 {
        //...
    }
    //...
}

注意：

内部类使用外部，可以随意访问，但是外部类使用内部类要借助内部类的对象。

使用成员内部类

两种方法：
1. 间接方式：在外部类的方法中，使用内部类，然后main只调用外部类的方法。
2. 直接方式：公式：
一般类：类名称 对象名 = new 类名称（）；
成员内部类：外部内名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();

Body.java含有一个内部类Heart

public class Body {

    private String name；

    //外部类方法
    public void methodBody() {
        System.out.println("外部类的方法");
        new Heart().beat();//在外部类方法中使用内部类。 
    }


    public  class Heart { //成员内部类
        //内部类方法
        public void  beat() {
            System.out.println("心脏跳动");
            System.out.println("我叫："+name);
        }
    }
}

下面分别介绍两种方式访问内部类：

间接方式访问内部类

Demo01InnerClass.java

public class Demo01InnerClass {
    public static void main(String[] args) {
        Body body = new Body();//外部类对象

        //通过外部类的对象，调用外部类的方法，里面间接使用内部类Heart
        body.methodBody();

直接方式访问内部类

public class Demo01InnerClass {
    public static void main(String[] args) {
        Body body = new Body();//外部类对对象

        //外部内名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
        Body.Heart heart = new Body().new Heart();
        heart.beat();
    }
}

外部类和内部类变量重名问题

当外部类的变量和内部类变量重名时，在内部类方法中访问外部类变量的格式是：外部类.this.外部类成员变量名

public class Outer {
    int number = 10;

    public class Inner {
        int number = 20;

        public  void methodInner() {
            int number =30;//内部类方法的局部变量
            System.out.println(number);//就近原则
            System.out.println(this.number);
            System.out.println(Outer.this.number);//外部类的成员变量
        }
    }
}

30
20
10

局部内部类

如果类是定义在一个方法内部的，那么这就是一个局部内部类。
“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。

定义格式：

修饰符 class 外部类名称 {
    修饰符 返回值类型  外部类方法名称(参数列表) {
        class 局部内部类名称 {
            //...
        }
    }
}

Outer.java含有局部内部类

public class Outer {
    public void methodOuter() {

        class Inner {
            int num = 10;
            public void methodInner() {
                System.out.println(num);//10
            }
        }
        //这个内部列只有当前所属方法能够访问这个类，出了这个方法就不能用了
        Inner inner = new Inner();
        inner.methodInner();
    }
}

DemoMain.java

public class DemoMain {

    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.methodOuter();
    }
}

结果：
10

注意：

局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】
备注：从java 8+开始，只要局部变量事实不变，那么final关键字可以省略。
原因：
1. new 出来的对象在堆内存当中。
2. 局部变量是跟着方法走的，在栈内存当中。
3. 方法运行结束后，立刻出栈，局部变量就会立刻消失。
4. 但是new出来的对象在堆当中持续存在，直到垃圾回收消失。

public class MyOuter {
    public void methodOuter() {
        final int num = 10;//所在方法的局部变量

        /*在栈中的局部变量可能随着方法结束出栈消失了，但是创建的内部类对象还存在。
        对象使用常量时能直接将常量copy进来，这时就要保证这个常量是不可更改的，也就是final。
        */
        //num = 20;

        class MyInner {
            public  void methodInner() {
                System.out.println(num);
            }
        }
        Inner myinner = new MyInner();
        inner.methodInner();
    }
}

修饰内部类的权限

public > protected > (default) > private
定义一个类的时候，权限修饰符规则：

1. 外部类：public / (default)
2. 成员内部类:都可以写，public > protected > (default) > private
3. 局部内部类:什么都不能写，但不是de

匿名内部类

如果接口的实现类（或者是父类的子类）只需要使用唯一的一次。
那么这种情况下就可以省略调该类的定义，而改为使用【匿名内部类】。

匿名内部类定义格式：

接口名称 对象名 = new 类名或者接口名称() {
    //覆盖重写所有抽象方法
};

代表继承了或者实现了该接口的子类对象。

==接口MyInterface.java==

public interface MyInterface {
    void method1();//抽象方法
    void method2();
}

==接口实现类MyInterfaceImp.java==

public class MyInterfaceImpl implements  MyInterface {


    @Override
    public void method1() {
        System.out.println("实现类覆盖重写了方法1");
    }

    @Override
    public void method2() {
        System.out.println("实现了覆盖重写方法2");
    }
}

测试类

一、一般接口实现方法

DemoMain.java

public class DemoMain {
    public static void main(String[] args) {
//        MyInterface impl = new MyInterfaceImpl();
//        impl.method();
        }
}

匿名内部类实现接口

DemoMain.java

public class DemoMain {
    public static void main(String[] args) {

        //使用匿名内部类，但不匿名对象，对象名称就叫obj
        MyInterface objA = new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法1-A");
            }
            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法2-A");
            }
        };
        objA.method1();
        objA.method2();

        System.out.println("----------我是分割线----------");

        //使用匿名内部类，而且省略了对象名称，也是匿名对象
        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法1-B");
            }
            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法2-B");
            }
        }.method1();
    }
}

结果：
匿名内部类实现了方法1-A
匿名内部类实现了方法2-A
----------我是分割线----------
匿名内部类实现了方法1-B

匿名内部内应用

• 实现倒计时5秒。

public class Demo02_Time {
    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("倒计时5秒");
            }
        },5000);//倒计时5秒
    }
}

注意事项：

对格式进行解析："new 接口名称 {...}；"进行解析

1. new代表创建对象的动作
2. 接口名称就是匿名内部类需要实现那个接口
3. {…}这才是匿名内部类的内容

注意：

1. 这个类只需要使用一次。匿名内部类在创建对象时，只能使用唯一一次。
   如果希望多次希望多次创建对象，而且内容一样的话，那么就必须使用单独定义的实现类。

2. 匿名对象，在调用的时候，只能调用唯一一次。
   如果希望同一个对象，调用多次方法，那么必须给对象取一个名字。

3. 匿名内部类是省略了【实现类/子类】，但是匿名对象是省略了【对象命名】。

强调：匿名和匿名对象不是一回事。

内部类与局部内部类

1、什么是内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

1.成员内部类 ：定义在类中方法外的类。

定义格式：

  class 外部类 {

         class内部类{

}

}       

2.访问特点

内部类可以直接访问外部类的成员，包括私有成员。 外部类要访问内部类的成员，必须要建立内部类的对象。

创建内部类对象格式：    

外部类名.内部类名 对象名=new 外部类名().new 内部类名()    

举例代码：

1.内部类

package DemoTest.DemoTest2;
public class person {
    private String name;
        public class xianren{
            public void XianShow(){
                System.out.println("仙人模式！");
                System.out.println("我叫"+name);
            }
        }

public void show(){
        System.out.println("间接调用内部类！");
        xianren xr = new xianren();
        xr.XianShow();
    }

    public person() {
    }
    public person(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

2.测试类

package DemoTest.DemoTest2;

public class Test {
    public static void main(String[] args) {

//第一种调用方法
        person p = new person();
        p.setName("鸣人");
        p.show();
        System.out.println("========================");

//第二种调用方法
        person.xianren x = p.new xianren();
        x.XianShow();
        System.out.println("========================");

//第三种调用方法
        //外部类名.内部类名 对象名=new 外部类名().new 内部类名()
        person.xianren obj= new person("鸣人").new xianren();
        obj.XianShow();
    }
}

3.结果:

间接调用内部类！

仙人模式！

我叫鸣人

========================

仙人模式！

我叫鸣人

========================

仙人模式！

我叫鸣人

举例代码2：

获取不同地址的值

1.不同位置的num
public class Denoquzhi {
    int num=10;
    class Quzhi{
        int num=20;
        public void print(){
            int num=30;
            System.out.println(num);
            System.out.println(this.num);
            System.out.println(Denoquzhi.this.num);
        }
    }
    public void da(){
        System.out.println("间接调用");
        Quzhi q = new Quzhi();
        q.print();
    }
}

2.测试类

package DemoTest.Demoquzhi;

public class Teat {
    public static void main(String[] args) {

//间接调用
        Denoquzhi d = new Denoquzhi();
        d.da();
        System.out.println("===================");

//格式规定的直接调用
        Denoquzhi.Quzhi dui=new Denoquzhi().new Quzhi();
        dui.print();
    }
}

3.结果：

间接调用

30

20

10

===================

30

20

10

2、局部内部类

举例代码：

1.在类的方法内包含了一个内部类

package DemoTest.DemoSamill;

public class Demosamill {
    public void method(){
        class MethodClass{
            int num=10;
            public void print(){
                System.out.println("局部内部类");
                System.out.println(num);
            }
        }
        MethodClass m = new MethodClass();
        m.print();
    }
}

2.测试类

package DemoTest.DemoSamill;

public class Test {
    public static void main(String[] args) {
        Demosamill d = new Demosamill();
        d.method();
    }
}

3.结果

局部内部类

10