1.什么是局部内部类

定义 ： 局部内部类是定义在外部类的局部位置，且一定要有类名；
局部内部类的本质仍然是一个类。

2.局部内部类的特性（关键）

 *      1. 可以直接访问 外部类 的所有成员，包括 私有的；
 *      2. 局部内部类 的地位相当于一个局部变量，因此不能添加访问修饰符，
 *         但可以使用final进行修饰；
 *      3. 作用域 ： 仅仅在定义它的方法或代码块中有效；
 *      4. 局部内部类 访问 外部类的成员 ： 直接访问即可；
 *      5. 外部类 访问 局部内部类的成员 ： 创建对象 -> 通过对象进行访问，
 *         注意 ： 需要在局部内部类的作用域中才可以；
 *      6. 如果 外部类 和 局部内部类 的成员重名时，默认遵循就近原则，
 *         如果就是想访问 外部类的成员时，使用 【外部类名.this.成员】 的方式

3.案例代码

3.1 局部内部类的定义代码

各位coder一定要跟着上面的特性来看这一段代码。

package com.northcastle.A_jubu_innerClass;

public class JubuInnerClass {

    // 1.外部类的属性
    private String field01 = "外部类的私有属性field01";
    public String field02 = "外部类的共有属性field02";

    // 2.外部类的构造器
    public JubuInnerClass() {
    }

    public JubuInnerClass(String field01, String field02) {
        this.field01 = field01;
        this.field02 = field02;
    }

    // 3.外部类的方法
    public void method01(){
        System.out.println("== 外部类的共有方法 ： method01 ");
    }
    private void method02(){
        System.out.println("== 外部类的私有方法 ： method02 ");
    }

    // * 包含内部类的方法
    public void method03(){

        System.out.println("== 外部类的方法03 begin ： 此方法包含一个局部内部类 == ");
        System.out.println();

        // 下面开始编写 局部内部类的代码
        class innerClass{
            // 1.局部内部类 的 属性
            private String field01_inner = "局部内部类的私有属性";
            public String field02_inner = "局部内部类的共有属性";
            private String field02 = "局部内部类的和外部类重名的属性";

            // 2.局部内部类的 构造器
            public innerClass() {
            }
            public innerClass(String field01_inner, String field02_inner, String field02) {
                this.field01_inner = field01_inner;
                this.field02_inner = field02_inner;
                this.field02 = field02;
            }

            //3.局部内部类的方法
            public void method01_inner(){
                System.out.println("--> 这是局部内部类的方法 method01_inner : begin <--");

                System.out.println("直接访问外部类的私有成员 field01 : "+field01);

                System.out.println("直接访问外部类的方法method01()、method02 ：");
                method01();
                method02();

                System.out.println("--> 这是局部内部类的方法 method01_inner : end <--");
            }

            public void method02_inner(){
                System.out.println("--> 这是局部内部类的方法 method02_inner 演示内部类如何访问同名的外部类的属性field02  begin <--");
                System.out.println("外部类的属性 field02 : "+JubuInnerClass.this.field02);
                System.out.println("--> 这是局部内部类的方法 method02_inner 演示内部类如何访问同名的外部类的属性field02  end <--");
            }
        } // innerClass end

        // 外部类访问内部类 ： 创建内部类的对象，通过对象进行访问
        innerClass innerClass = new innerClass();
        innerClass.method01_inner();
        System.out.println();
        innerClass.method02_inner();

        System.out.println();
        System.out.println("== 外部类的方法03 end ： 此方法包含一个局部内部类 == ");

    }
}

3.2 局部内部类的使用代码

package com.northcastle.A_jubu_innerClass;

public class Application {
    public static void main(String[] args) {
        //本代码演示使用内部类的情况
        JubuInnerClass jubuInnerClass = new JubuInnerClass();
        jubuInnerClass.method03();
    }
}

3.3 运行结果

4.完成

Congratulations!
You are one step closer to success!

一、什么是内部类？or 内部类的概念

内部类是定义在另一个类中的类；下面类TestB是类TestA的内部类。即内部类对象引用了实例化该内部对象的外围类对象。

public class TestA{
    class TestB {}
}

二、 为什么需要内部类？or 内部类有什么作用？

1、 内部类方法可以访问该类定义所在的作用域中的数据，包括私有数据。
2、内部类可以对同一个包中的其他类隐藏起来。
3、 当想要定义一个回调函数且不想编写大量代码时，使用匿名内部类比较便捷。

三、 内部类的分类

成员内部类，局部内部类，匿名内部类，静态内部类

3.1 成员内部类

成员内部类：存在于某个类的内部，与全局属性或者方法同级的内部类就是成员内部类。
举一个成员内部类实例：

public class Person{
    public void run(){}
    public class DoWork implements Work{}
}

成员内部类特点：

1、（重要）成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括静态成员和私有成员）。！！很重要
2、成员内部类和外部类的属性和方法名同名时，外部类的属性和方法会隐藏；但可以通过外部类.this.成员变量的方式访问外部类的属性和方法。
3、 外部类必须通过成员内部类的对象来访问内部类的属性和方法。
4、 成员内部类对象会隐式的引用一个外部类对象。（可以解释第一点）
5、 成员内部类可以有public\private\protected以及默认访问权限。

3.2 局部内部类

举一个局部内部类实例：

public class Person{
    public void run(){
         class DoWork implements Work{}
    }
}

注意：和成员内部类的区别，局部内部类在方法里面

局部内部类：是定义在一个方法或者一个作用域里面的类。它与成员内部类的区别在于局部内部类的访问仅在于方法内或者作用域内。
局部内部类的特点：

1、 不能有private、public、protected和static等修饰符，与局部变量类似。
2、只能在定义局部内部类的方法或者作用域中实例化；
3、 局部内部类的对象不能使用该内部类所在方法或者作用域的非final局部变量（为什么？）；

3.3 匿名内部类
举一个匿名内部类实例：

public class Person{
    public DoWork doSomething(){
        return new DoWork(){
            public void do(){}
        };
    }
}

什么是匿名内部类：不定义类的名字，在使用的地方直接定义对象。
匿名内部类的特点：

1、唯一一种没有构造器的类；匿名内部类在编译时，编译器会自动起名xxx$1.class;
2、 匿名内部类不能存在任何静态的变量、方法等；
3、 匿名内部类是局部内部类的特例；
4、大部分匿名内部类用于接口返回；

3.4 静态内部类

举一个静态内部类实例：

public class Person{
    public void run(){}
    public static class DoWork implements Work{}
}

注意和成员内部类的区别
静态内部类：在成员内部类的基础上加上一个static关键字就是静态内部类。
静态内部类的特点：

1、不需要依赖外部类。
2、不能使用外部类的非静态属性和方法。

例题：

下列说法正确的是（AB）？

A、对于局部内部类，只有在方法的局部变量被标记为final或局部变量是effctively final的，内部类才能使用它们
B、 成员内部类位于外部类内部，可以直接调用外部类的所有方法（静态方法和非静态方法）
C、由于匿名内部类只能用在方法内部，所以匿名内部类的用法与局部内部类是一致的
D、静态内部类可以直接访问外部类的非静态成员

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