局部内部类
局部内部类是内部类的第二种形式，它让内部类的“隐藏”得更深一层——写在外部类的方法内部，而不是处于和外部类方法平行的位置。
让我们对上面成员内部类处理的场景做些思考：我们的Inner内部类仅仅只在outterPrint方法中使用了一次：
public void outterPrint () {
Inner i = new Inner();
i.innerPrint();
}
那么我们能不能把Inner内部类直接定义在outterPrint的内部呢？****这样的话，它就能更好地隐藏起来，即使是类Outter中除outterPrint外的方法，也不能访问到它：
现在的Outter的类看起来像这样：
public class Outter {
public void outterPrint () {// 外部类方法
class LocalInner { // 局部内部类
public void innerPrint () { }
}
LocalInner i = new LocalInner(); // 实例化局部内部类
i.innerPrint();
}
}
相比于成员内部类，局部内部类多了一项能访问的数据，那就是局部变量（由外部类方法提供）
成员内部类：外部类数据，内部类数据
局部内部类： 外部类数据，内部类数据， 局部数据
具体示例如下：
public class Outter {
private String data = "外部数据"; // 外部类数据
public void outterPrint (final String localData) { // 局部数据
class LocalInner {
private String data = "内部数据"; // 内部类数据
public void innerPrint () {
System.out.println(Outter.this.data); // 打印外部类数据
System.out.println(this.data); // 打印内部类数据
System.out.println(localData); // 打印局部数据
}
}
LocalInner i = new LocalInner();
i.innerPrint();
}
}
Test.java:
public class Test {
public static void main (String [] args) {
Outter o = new Outter();
o.outterPrint("局部数据");
}
}
结果输出：
外部数据
内部数据
局部数据
局部类所使用的外部类方法的形参必须用final修饰
这里要注意一点， 局部类所使用的外部类方法的形参必须用final修饰，否则会编译不通过，也就是说传入后不许改变
为什么这个方法形参一定要用final修饰？
** (仅个人理解，如有不同的意见或者更好的理解欢迎在评论区讨论)**
如果不用final修饰会怎样？ 且听我慢慢道来：
首先要说一下：
1.内部类和外部类在编译之后形式上是一样的，不会有内外之分
2.局部内部类对于使用的外部方法的值会用构造函数做一个拷贝（编译后）
例如对于下面outterPrint方法中的LocalInner
public void outterPrint (final String data) {
class LocalInner {
public void innerPrint () {
// 使用 data
}
}
}
编译之后大概长这样：
public class Outter$LocalInner{
public LocalInner(String data){
this.LocalInner$data = data; // 对于使用的data做了一次拷贝
}
public void innerPrint (){ /* 使用 data */ }
}
这里要注意的是：
1. 编译后，LocalInner并非直接使用data，而是用构造器拷贝一份后再使用
2. java是值传递的，所以包裹 LocalInner的外部方法outterPrint也会对传入的data参数做一次拷贝（基本类型数据拷贝副本，对象等则拷贝引用）
ＯＫ，现在的情况是：
方法内的局部类对data拷贝了两次：外部方法outterPrint值传递时的拷贝，和LocalInner构造函数的拷贝
方法内除了局部类外的作用域只拷贝了data一次： 外部方法outterPrint值传递时的拷贝
拷贝两次和拷贝一次，导致在outterPrint方法内部， 局部类内部的data和局部类外部的data是不同步的！ 也即你在局部类内部改了data不影响局部类外部的data，在局部类外部改了data也不影响局部类内部的data（注意一个前提，值是基本类型的，如果是对象的话因为拷贝的是引用仍然可以“同步”）
图示一：
图示二：
于是java说： 哎呀妈呀， 这都data都不同步了， 要是让你修改这还了得!!! 于是就强行要求我们加上final
【注意】所谓的不同步主要是针对基本类型来说的，如果是对象之类的话因为拷贝的是引用所以仍然可以“同步”
如何突破必须用final的限制
我们上面说到，局部内部类所使用的方法形参必须用final修饰的限制。
例如
public void outterPrint (String data) {// 没加上final
class LocalInner {
public void changeData () {
data = "我想修改data的值"; // 在这一行编译报错
}
}
}
提示：
Cannot refer to a non-final variable data inside an inner class defined in a different method
那么，如果我们有对该形参必须能修改的硬性需求怎么办？
你可以通过一种有趣的方式绕开它：使用一个单元素数组。因为用final修饰的基本类型的变量不允许修改值，但是却允许修改final修饰的单元素数组里的数组元素， 因为存放数组的变量的值只是一个引用，我们修改数组元素的时候是不会修改引用指向的地址的，在这点上final并不会妨碍我们：
Outter.java
public class Outter {
public void outterPrint (final String [] data) {
class LocalInner {
public void innerPrint () {
data[0] = "堂而皇之地修改它！！"; // 修改数据
System.out.print(data[0]); // 输出修改后的数据
}
}
LocalInner i = new LocalInner();
i.innerPrint();
}
}
Test.java:
public class Test {
public static void main (String [] args) {
Outter o = new Outter();
String [] data = new String [1];
data[0] = "我是数据";
o.outterPrint(data); // 修改数据并且输出
}
}
结果输出：
堂而皇之地修改它！！
【注意】局部类不能用public或private访问符进行声明！！
名内部类
倘若我们再把局部内部类再深化一下， 那就是匿名内部类
匿名内部类的使用方式
new [超类/接口] { /* 类体 */ }
让我们看看下面这个例子：
Other.java:
public class Other { }
Outter.java:
public class Outter { public void outterPrint (String data) { Other o = new Other() { }; // 匿名内部类 }}
何谓之匿名？
“诶，不是说好的匿名吗？ 那么为什么还有个Other的类名呢？”
Other o = new Other() { /* 匿名内部类的类体 */ };
实际上，这里的Other并不是我们的匿名内部类，而是我们匿名内部类的超类，上面一行代码其实相当于(用成员内部类来表示的话)
// annoymous翻译为匿名
public class Outter {
private class annoymous extends Other{ }
public void outterPrint () {
Other a = new annoymous();
}
}
同时要注意，我们在使用匿名内部类的方式，是在定义一个内部类的同时实例化该内部类：
new Other() { /* 匿名内部类的类体 */ }; // new操作和定义类的代码是紧紧结合在一起的
匿名函数的作用
用匿名函数的作用在于在一些特定的场景下写起来很简单，例如事件监听器：
ActionListener listener = new ActionListener() {
public void actionPerformed(ActionEvent e) { }
};
避免了再创建另外一个类文件
讲的有点乱， 对匿名内部类做个总结：
- 省略被定义的类的类名
- 必须结合超类或者接口使用，即 new [超类/接口] { /* 类体 */ }
- 在定义该匿名类的同时实例化该匿名类
- 在一些场景下能简化代码
【注意】匿名类不能有构造器， 因为构造器和类同名，而匿名类没有类名，所以匿名类不能有构造器
文章总结
我们使用内部类的原因主要有三点：
1.实现数据隐藏， 避免多余的可见性
2.自由访问外部类的变量
- 在使用监听器等场景的时候使用匿名内部类，避免增加的大量代码
关于成员内部类， 方法局部类，匿名内部类的关系
从成员内部类，方法局部类到匿名内部类是一个不断深入的关系， 成员内部类进一步隐藏可见性就成为了方法局部类， 方法局部类省去类名，并将类的定义和实例化操作合并到一起，就是匿名内部类。因此，匿名内部类沿袭了成员内部类和方法局部类的基本特特
内部类的一些特殊的要求
1.局部类不能用public或private访问符进行声明
2.局部类所使用的外部类方法的形参必须用final修饰 - 匿名内部类不能有构造器
