classOuter {classInner {

}

}

(二) 内部类的访问规则

​ 　　A:可以直接访问外部类的成员，包括私有

​ 　　B:外部类要想访问内部类成员，必须创建对象

(三) 内部类的分类

​ 　　A：成员内部类

​ B：局部内部类

​ C：静态内部类

​ 　　D：匿名内部类

为什么要使用内部类？

有的时候你可能有这样一种需求：对一个类(假设它为MyClass.java)创建一个和它相关的类(假设它是Part.java)，但因为Part.java和MyClass之间的联系“紧密”且“单一”，导致我们在这种情况下，不希望像下面这样增加一个额外的兄弟类

├─MyClass

└─Part

而希望能将Part.java的数据隐藏在MyClass.java内部，于是这个时候内部类就堂而皇之地出现了

那么，这个不请自来的内部类到底给我们上述的局面造成了怎样的改变呢？ 让我们来看看：

增加一个额外的兄弟类Part:

1. 对一些没有关联的类可见(如果protected则对同一包内类可见，如果public则对所有类可见)

2. 不能完全自由的访问MyClass中的私有数据(必须经过访问器方法)

3. 新增了一个java文件

使用内部类，将Part类的定义写入MyClass内部

1. 可以减少多余的可见性，例如可把Part在MyClass内部定义为私有，这样对同一包内其他类也不可见了

2. 内部类(Part)可以自由访问外围类的所有数据(MyClass)，包括私有数据

3. 减少了一个java文件，使得类结构更简洁

成员内部类

故名思议，成员内部类嘛~  使用当然和成员变量很相似咯

你可以像

private String data

这样定义一个“平行的”成员内部类:

private class Inner

具体看下面的例子：

Outter.java:

public classOutter {//成员变量data

private String data = "外部数据";//定义一个内部类

private classInner {public voidinnerPrint () {

System.out.println(data);

}

}//外部类的方法， new一个内部类的实例并调用其innerPrint方法

public voidoutterPrint () {

Inner i= newInner();

i.innerPrint();

}

}

Test.java:

public classTest {public static voidmain (String [] args) {

Outter o= newOutter();

o.outterPrint();

}

}

结果输出：

外部数据

看来这还是能达到我们预期的效果的：由于将Inner内部类设为private，它变得只对我们当前的外部类Outter类可见，我们成功地把它"隐藏"在了Outter类内部，与此同时，它还自由地访问到了Outter类的私有成员变量data

两个this

虽然上面的例子看起来挺简单的，但实际上内部类的作用机制还是比较复杂的。

首先要考虑的是“this”的问题，外部类和内部类各有一个this，关键在于内部类中我们如何对这两个this作出区分：

我们假设上面的例子中的Inner类内部有一个方法fn:

private classInner {public voidfn () {

Outter.this //指向Outter实例对象的this引用

this //指向Inner实例对象的this引用

}

}

在这个方法fn里，Outter.this是指向Outter实例对象的this的引用， 而this是指向Inner实例对象的this的引用

我们访问类中成员变量有两种方式： 隐式访问(不加this)和显式访问(加this)

隐式访问类中成员变量

让我们对上面的Outter.java做一些改动，增加一行代码：

ublic classOutter {//成员变量data

private String data = "外部数据";//定义一个内部类

private classInner {//增加Inner类对data成员变量的声明

private String data = "内部数据" public voidinnerPrint () {

System.out.println(data);

}

}//外部类的方法， new一个内部类的实例并调用其innerPrint方法

public voidoutterPrint () {

Inner i= newInner();

i.innerPrint();

}

}

结果输出：

内部数据

如此可见，内部类内声明的数据会覆盖外部类的同名数据。或者说, 在上述例子中，对于data成员变量，它会首先在Inner的this中查找有无这个成员变量，然后没有，那么就再在Outter.this中查找

显式访问类中成员变量

但有的时候我们希望既能访问外部类的成员变量，同时也能访问内部类的成员变量，这个时候我们就要使用到this了，但是如何区分内部类和外部类的this呢？你可以这样：

以上述例子为例：

访问外部类定义的成员变量：Outter.this.data

访问内部类定义的成员变量：this.data

如下图所示

public classOutter {//外部类的成员变量data

private String data = "外部数据";//定义一个内部类

private classInner {//内部类的成员变量data

private String data = "内部数据";public voidinnerPrint () {

System.out.println(Outter.this.data);

System.out.println(this.data);

}

}//外部类的方法， new一个内部类的实例并调用其innerPrint方法

public voidoutterPrint () {

Inner i= newInner();

i.innerPrint();

}

}

局部内部类

局部内部类是内部类的第二种形式，它让内部类的“隐藏”得更深一层——写在外部类的方法内部，而不是处于和外部类方法平行的位置。

让我们对上面成员内部类处理的场景做些思考：我们的Inner内部类仅仅只在outterPrint方法中使用了一次：

public voidoutterPrint () {

Inner i= newInner();

i.innerPrint();

}

那么我们能不能把Inner内部类直接定义在outterPrint的内部呢？这样的话，它就能更好地隐藏起来，即使是类Outter中除outterPrint外的方法，也不能访问到它：

现在的Outter的类看起来像这样：

public classOutter {public void outterPrint () {//外部类方法

class LocalInner { //局部内部类

public voidinnerPrint () { }

}

LocalInner i= new LocalInner(); //实例化局部内部类

i.innerPrint();

}

}

相比于成员内部类，局部内部类多了一项能访问的数据，那就是局部变量(由外部类方法提供)

成员内部类：外部类数据，内部类数据

局部内部类： 外部类数据，内部类数据， 局部数据

具体示例如下：

Outter.java

public classOutter {private String data = "外部数据"; //外部类数据

public void outterPrint (final String localData) { //局部数据

classLocalInner {private String data = "内部数据"; //内部类数据

public voidinnerPrint () {

System.out.println(Outter.this.data); //打印外部类数据

System.out.println(this.data); //打印内部类数据

System.out.println(localData); //打印局部数据

}

}

LocalInner i= newLocalInner();

i.innerPrint();

}

}

Test.java:

public classTest {public static voidmain (String [] args) {

Outter o= newOutter();

o.outterPrint("局部数据");

}

}

结果输出：

外部数据

内部数据

局部数据

局部类所使用的外部类方法的形参必须用final修饰

这里要注意一点， 局部类所使用的外部类方法的形参必须用final修饰，否则会编译不通过，也就是说传入后不许改变

为什么这个方法形参一定要用final修饰？

(仅个人理解，如有不同的意见或者更好的理解欢迎在评论区讨论)

如果不用final修饰会怎样？ 且听我慢慢道来：

首先要说一下：

1.内部类和外部类在编译之后形式上是一样的，不会有内外之分

2.局部内部类对于使用的外部方法的值会用构造函数做一个拷贝(编译后)

例如对于下面outterPrint方法中的LocalInner

public void outterPrint (finalString data) {classLocalInner {public voidinnerPrint () {//使用 data

}

}

}

编译之后大概长这样：

public classOutter$LocalInner{publicLocalInner(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

classLocalInner {public voidchangeData () {

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 classOutter {public void outterPrint (finalString [] data) {classLocalInner {public voidinnerPrint () {

data[0] = "堂而皇之地修改它！！"; //修改数据

System.out.print(data[0]); //输出修改后的数据

}

}

LocalInner i= newLocalInner();

i.innerPrint();

}

}

Test.java:

public classTest {public static voidmain (String [] args) {

Outter o= newOutter();

String [] data= new String [1];

data[0] = "我是数据";

o.outterPrint(data);//修改数据并且输出

}

}

结果输出：

堂而皇之地修改它！！

【注意】局部类不能用public或private访问符进行声明！！

匿名内部类

倘若我们再把局部内部类再深化一下， 那就是匿名内部类

匿名内部类的使用方式

new [超类/接口] { /*类体*/ }

让我们看看下面这个例子：

Other.java:

public class Other { }

Outter.java:

public classOutter {public voidoutterPrint (String data) {

Other o= new Other() { }; //匿名内部类

}

}

何谓之匿名？

“诶，不是说好的匿名吗？ 那么为什么还有个Other的类名呢？”

Other o = new Other() { /*匿名内部类的类体*/ };

实际上，这里的Other并不是我们的匿名内部类，而是我们匿名内部类的超类，上面一行代码其实相当于(用成员内部类来表示的话)

//annoymous翻译为匿名

public classOutter {private class annoymous extendsOther{ }public voidoutterPrint () {

Other a= newannoymous();

}

}

同时要注意，我们在使用匿名内部类的方式，是在定义一个内部类的同时实例化该内部类：

new Other() { /*匿名内部类的类体*/ }; //new操作和定义类的代码是紧紧结合在一起的

匿名函数的作用

用匿名函数的作用在于在一些特定的场景下写起来很简单，例如事件监听器：

ActionListener listener = newActionListener() {public voidactionPerformed(ActionEvent e) { }

};

避免了再创建另外一个类文件

讲的有点乱， 对匿名内部类做个总结：

1. 省略被定义的类的类名

2. 必须结合超类或者接口使用，即 new [超类/接口] {   /* 类体 */   }

3. 在定义该匿名类的同时实例化该匿名类

4. 在一些场景下能简化代码

【注意】匿名类不能有构造器， 因为构造器和类同名，而匿名类没有类名，所以匿名类不能有构造器

文章总结

我们使用内部类的原因主要有三点：

1.实现数据隐藏， 避免多余的可见性

2.自由访问外部类的变量

3. 在使用监听器等场景的时候使用匿名内部类，避免增加的大量代码

关于成员内部类， 方法局部类，匿名内部类的关系

从成员内部类，方法局部类到匿名内部类是一个不断深入的关系， 成员内部类进一步隐藏可见性就成为了方法局部类， 方法局部类省去类名，并将类的定义和实例化操作合并到一起，就是匿名内部类。因此，匿名内部类沿袭了成员内部类和方法局部类的基本特特性

内部类的一些特殊的要求

1.局部类不能用public或private访问符进行声明

2.局部类所使用的外部类方法的形参必须用final修饰

3. 匿名内部类不能有构造器

参考资料：

《java核心技术 卷1》—— Cay S. Horstmann, Gary Cornell