說起內部類別這個詞，想必很多人都不陌生，但是又會覺得不熟悉。原因是平常寫程式碼時可能用到的場景不多，用得最多的是在有事件監聽的情況下，並且即使用到也很少去總結內部類別的用法。今天我們就來一探究竟。
一.內部類別基礎
在Java中，可以將一個類別定義在另一個類別裡面或一個方法裡面，這樣的類別稱為內部類別。廣義的內部類別一般來說包括這四種：成員內部類別、局部內部類別、匿名內部類別和靜態內部類別。下面就先來了解這四種內部類別的用法。
1.成員內部類別
成員內部類別是最普通的內部類，它的定義為位於另一個類別的內部，形狀如下面的形式：
class Circle {
double radius = 0;
public Circle(double radius) {
this.radius = radius;
}
class Draw { //内部类
public void drawSahpe() {
System.out.println("drawshape");
}
}
}這樣看起來，類別Draw像是類別Circle的一個成員，Circle稱為外部類別。成員內部類別可以無條件存取外部類別的所有成員屬性和成員方法（包括private成員和靜態成員）。
class Circle {
private double radius = 0;
public static int count =1;
public Circle(double radius) {
this.radius = radius;
}
class Draw { //内部类
public void drawSahpe() {
System.out.println(radius); //外部类的private成员
System.out.println(count); //外部类的静态成员
}
}
}不過要注意的是，當成員內部類別擁有和外部類別同名的成員變數或方法時，會發生隱藏現象，即預設情況下存取的是成員內部類別的成員。如果要存取外部類別的同名成員，需要以下面的形式進行存取：
外部類別.this.成員變數
外部類別.this.成員方法
雖然成員內部類別可以無條件地存取外部類別的成員，而外部類別想存取成員內部類別的成員卻不是這麼隨心所欲了。在外部類別中如果要存取成員內部類別的成員，必須先建立一個成員內部類別的對象，再透過指向這個物件的參考來存取：
class Circle {
private double radius = 0;
public Circle(double radius) {
this.radius = radius;
getDrawInstance().drawSahpe(); //必须先创建成员内部类的对象，再进行访问
}
private Draw getDrawInstance() {
return new Draw();
}
class Draw { //内部类
public void drawSahpe() {
System.out.println(radius); //外部类的private成员
}
}
}成員內部類別是依附外部類別而存在的，也就是說，如果要建立成員內部類別的對象，前提是必須存在一個外部類別的物件。建立成員內部類別物件的一般方式如下：
public class Test {
public static void main(String[] args) {
//第一种方式：
Outter outter = new Outter();
Outter.Inner inner = outter.new Inner(); //必须通过Outter对象来创建
//第二种方式：
Outter.Inner inner1 = outter.getInnerInstance();
}
}
class Outter {
private Inner inner = null;
public Outter() {
}
public Inner getInnerInstance() {
if(inner == null)
inner = new Inner();
return inner;
}
class Inner {
public Inner() {
}
}
}內部類別可以擁有private存取權、protected存取權、public存取權限及套件存取權。例如上面的例子，如果成員內部類別Inner用private修飾，則只能在外部類別的內部訪問，如果用public修飾，則任何地方都能訪問；
如果用protected修飾，則只能在同一個套件下或繼承外部類別的情況下存取；如果是預設存取權限，則只能在同一個套件下存取。這一點和外部類別有一點不一樣，外部類別只能被public和套件存取兩種權限修飾。
2.局部內部類別
局部內部類別是定義在一個方法或一個作用域裡面的類，它和成員內部類別的差別在於局部內部類的存取僅限於方法內或該作用域內。
class People{
public People() {
}
}
class Man{
public Man(){
}
public People getWoman(){
class Woman extends People{ //局部内部类
int age =0;
}
return new Woman();
}
}注意，局部內部類別就像是方法裡面的局部變數一樣，是不能有public、protected、private以及static修飾符的。
3.匿名內部類別
匿名內部類別應該是平時我們寫程式碼時用得最多的，在寫事件監聽的程式碼時使用匿名內部類別不但方便，而且使程式碼更加容易維護。下面這段程式碼是一段Android事件監聽程式碼：
scan_bt.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
}
});
history_bt.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
}
});這段程式碼為兩個按鈕設定監聽器，這裡面就使用了匿名內部類別。這段程式碼中的：
new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
}
}就是匿名內部類別的使用。程式碼中需要給按鈕設定監聽器對象，使用匿名內部類別能夠在實作父類別或介面中的方法情況下同時產生一個對應的對象，但是前提是這個父類別或介面必須先存在才能這樣使用。當然像下面這種寫法也是可以的，跟上面使用匿名內部類別達到效果相同。
private void setListener()
{
scan_bt.setOnClickListener(new Listener1());
history_bt.setOnClickListener(new Listener2());
}
class Listener1 implements View.OnClickListener{
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
}
}
class Listener2 implements View.OnClickListener{
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
}
}這種寫法雖然能達到一樣的效果，但是既冗長又難以維護，所以一般使用匿名內部類別的方法來編寫事件監聽程式碼。同樣的，匿名內部類別也是不能有存取修飾符和static修飾符的。
匿名內部類別是唯一沒有建構器的類別。正因為沒有構造器，所以匿名內部類別的使用範圍非常有限，大部分匿名內部類別用於介面回呼。匿名內部類別在編譯的時候由系統自動命名為Outter$1.class。
一般來說，匿名內部類別用於繼承其他類別或是實作接口，並不需要增加額外的方法，只是對繼承方法的實作或重寫。
4.靜態內部類別
靜態內部類別也是定義在另一個類別裡面的類，只不過在類別的前面多了一個關鍵字static。靜態內部類別是不需要依賴外部類別的，這點和類別的靜態成員屬性有點類似，而且它不能使用外部類別的非static成員變數或方法，這一點很好理解，因為在沒有外部類別的對象的情況下，可以建立靜態內部類別的對象，如果允許存取外部類別的非static成員就會產生矛盾，因為外部類別的非static成員必須依附於特定的對象。
public class Test {
public static void main(String[] args) {
Outter.Inner inner = new Outter.Inner();
}
}
class Outter {
public Outter() {
}
static class Inner {
public Inner() {
}
}
}
二.深入理解内部类
1.为什么成员内部类可以无条件访问外部类的成员？
在此之前，我们已经讨论过了成员内部类可以无条件访问外部类的成员，那具体究竟是如何实现的呢？下面通过反编译字节码文件看看究竟。事实上，编译器在进行编译的时候，会将成员内部类单独编译成一个字节码文件，下面是Outter.java的代码：
public class Outter {
private Inner inner = null;
public Outter() {
}
public Inner getInnerInstance() {
if(inner == null)
inner = new Inner();
return inner;
}
protected class Inner {
public Inner() {
}
}
}编译之后，出现了两个字节码文件：
反编译Outter$Inner.class文件得到下面信息：
E:\Workspace\Test\bin\com\cxh\test2>javap -v Outter$Inner
Compiled from "Outter.java"
public class com.cxh.test2.Outter$Inner extends java.lang.Object
SourceFile: "Outter.java"
InnerClass:
#24= #1 of #22; //Inner=class com/cxh/test2/Outter$Inner of class com/cxh/tes
t2/Outter
minor version: 0
major version: 50
Constant pool:
const #1 = class #2; // com/cxh/test2/Outter$Inner
const #2 = Asciz com/cxh/test2/Outter$Inner;
const #3 = class #4; // java/lang/Object
const #4 = Asciz java/lang/Object;
const #5 = Asciz this$0;
const #6 = Asciz Lcom/cxh/test2/Outter;;
const #7 = Asciz <init>;
const #8 = Asciz (Lcom/cxh/test2/Outter;)V;
const #9 = Asciz Code;
const #10 = Field #1.#11; // com/cxh/test2/Outter$Inner.this$0:Lcom/cxh/t
est2/Outter;
const #11 = NameAndType #5:#6;// this$0:Lcom/cxh/test2/Outter;
const #12 = Method #3.#13; // java/lang/Object."<init>":()V
const #13 = NameAndType #7:#14;// "<init>":()V
const #14 = Asciz ()V;
const #15 = Asciz LineNumberTable;
const #16 = Asciz LocalVariableTable;
const #17 = Asciz this;
const #18 = Asciz Lcom/cxh/test2/Outter$Inner;;
const #19 = Asciz SourceFile;
const #20 = Asciz Outter.java;
const #21 = Asciz InnerClasses;
const #22 = class #23; // com/cxh/test2/Outter
const #23 = Asciz com/cxh/test2/Outter;
const #24 = Asciz Inner;
{
final com.cxh.test2.Outter this$0;
public com.cxh.test2.Outter$Inner(com.cxh.test2.Outter);
Code:
Stack=2, Locals=2, Args_size=2
0: aload_0
1: aload_1
2: putfield #10; //Field this$0:Lcom/cxh/test2/Outter;
5: aload_0
6: invokespecial #12; //Method java/lang/Object."<init>":()V
9: return
LineNumberTable:
line 16: 0
line 18: 9
LocalVariableTable:
Start Length Slot Name Signature
0 10 0 this Lcom/cxh/test2/Outter$Inner;
}第11行到35行是常量池的内容，下面逐一第38行的内容：
final com.cxh.test2.Outter this$0;
这行是一个指向外部类对象的指针，看到这里想必大家豁然开朗了。也就是说编译器会默认为成员内部类添加了一个指向外部类对象的引用，那么这个引用是如何赋初值的呢？下面接着看内部类的构造器：
public com.cxh.test2.Outter$Inner(com.cxh.test2.Outter);
从这里可以看出，虽然我们在定义的内部类的构造器是无参构造器，编译器还是会默认添加一个参数，该参数的类型为指向外部类对象的一个引用，所以成员内部类中的Outter this&0 指针便指向了外部类对象，因此可以在成员内部类中随意访问外部类的成员。
从这里也间接说明了成员内部类是依赖于外部类的，如果没有创建外部类的对象，则无法对Outter this&0引用进行初始化赋值，也就无法创建成员内部类的对象了。
2.为什么局部内部类和匿名内部类只能访问局部final变量？
想必这个问题也曾经困扰过很多人，在讨论这个问题之前，先看下面这段代码：
public class Test {
public static void main(String[] args) {
}
public void test(final int b) {
final int a = 10;
new Thread(){
public void run() {
System.out.println(a);
System.out.println(b);
};
}.start();
}
}这段代码会被编译成两个class文件：Test.class和Test1.class。默认情况下，编译器会为匿名内部类和局部内部类起名为Outter1.class。默认情况下，编译器会为匿名内部类和局部内部类起名为Outterx.class（x为正整数）。
根据上图可知，test方法中的匿名内部类的名字被起为 Test$1。
上段代码中，如果把变量a和b前面的任一个final去掉，这段代码都编译不过。我们先考虑这样一个问题：
当test方法执行完毕之后，变量a的生命周期就结束了，而此时Thread对象的生命周期很可能还没有结束，那么在Thread的run方法中继续访问变量a就变成不可能了，但是又要实现这样的效果，怎么办呢？Java采用了 复制 的手段来解决这个问题。将这段代码的字节码反编译可以得到下面的内容：
我们看到在run方法中有一条指令：
bipush 10
这条指令表示将操作数10压栈，表示使用的是一个本地局部变量。这个过程是在编译期间由编译器默认进行，如果这个变量的值在编译期间可以确定，则编译器默认会在匿名内部类（局部内部类）的常量池中添加一个内容相等的字面量或直接将相应的字节码嵌入到执行字节码中。这样一来，匿名内部类使用的变量是另一个局部变量，只不过值和方法中局部变量的值相等，因此和方法中的局部变量完全独立开。
下面再看一个例子：
public class Test {
public static void main(String[] args) {
}
public void test(final int a) {
new Thread(){
public void run() {
System.out.println(a);
};
}.start();
}
}反编译得到：
我们看到匿名内部类Test$1的构造器含有两个参数，一个是指向外部类对象的引用，一个是int型变量，很显然，这里是将变量test方法中的形参a以参数的形式传进来对匿名内部类中的拷贝（变量a的拷贝）进行赋值初始化。
也就说如果局部变量的值在编译期间就可以确定，则直接在匿名内部里面创建一个拷贝。如果局部变量的值无法在编译期间确定，则通过构造器传参的方式来对拷贝进行初始化赋值。
从上面可以看出，在run方法中访问的变量a根本就不是test方法中的局部变量a。这样一来就解决了前面所说的 生命周期不一致的问题。
但是新的问题又来了，既然在run方法中访问的变量a和test方法中的变量a不是同一个变量，当在run方法中改变变量a的值的话，会出现什么情况？
对，会造成数据不一致性，这样就达不到原本的意图和要求。为了解决这个问题，java编译器就限定必须将变量a限制为final变量，不允许对变量a进行更改（对于引用类型的变量，是不允许指向新的对象），这样数据不一致性的问题就得以解决了。
到这里，想必大家应该清楚为何 方法中的局部变量和形参都必须用final进行限定了。
3.静态内部类有特殊的地方吗？
从前面可以知道，静态内部类是不依赖于外部类的，也就说可以在不创建外部类对象的情况下创建内部类的对象。另外，静态内部类是不持有指向外部类对象的引用的，这个读者可以自己尝试反编译class文件看一下就知道了，是没有Outter this&0引用的。
三.内部类的使用场景和好处
为什么在Java中需要内部类？总结一下主要有以下四点：
1.每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。内部类使得多继承的解决方案变得完整，
2.方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏。
3.方便编写事件驱动程序
4.方便编写线程代码
四.常见的与内部类相关的笔试面试题
1.根据注释填写(1)，(2)，(3)处的代码
public class Test{
public static void main(String[] args){
// 初始化Bean1
(1)
bean1.I++;
// 初始化Bean2
(2)
bean2.J++;
//初始化Bean3
(3)
bean3.k++;
}
class Bean1{
public int I = 0;
}
static class Bean2{
public int J = 0;
}
}
class Bean{
class Bean3{
public int k = 0;
}
}从前面可知，对于成员内部类，必须先产生外部类的实例化对象，才能产生内部类的实例化对象。而静态内部类不用产生外部类的实例化对象即可产生内部类的实例化对象。
创建静态内部类对象的一般形式为： 外部类类名.内部类类名 xxx = new 外部类类名.内部类类名()
创建成员内部类对象的一般形式为： 外部类类名.内部类类名 xxx = 外部类对象名.new 内部类类名()
因此，（1），（2），（3）处的代码分别为：
Test test = new Test(); Test.Bean1 bean1 = test.new Bean1();
Test.Bean2 b2 = new Test.Bean2();
Bean bean = new Bean(); Bean.Bean3 bean3 = bean.new Bean3();
2.下面这段代码的输出结果是什么？
public class Test {
public static void main(String[] args) {
Outter outter = new Outter();
outter.new Inner().print();
}
}
class Outter
{
private int a = 1;
class Inner {
private int a = 2;
public void print() {
int a = 3;
System.out.println("局部变量：" + a);
System.out.println("内部类变量：" + this.a);
System.out.println("外部类变量：" + Outter.this.a);
}
}
}3
2
1
最后补充一点知识：关于成员内部类的继承问题。一般来说，内部类是很少用来作为继承用的。但是当用来继承的话，要注意两点：
1）成员内部类的引用方式必须为 Outter.Inner.
2）构造器中必须有指向外部类对象的引用，并通过这个引用调用super()。
class WithInner {
class Inner{
}
}
class InheritInner extends WithInner.Inner {
// InheritInner() 是不能通过编译的，一定要加上形参
InheritInner(WithInner wi) {
wi.super(); //必须有这句调用
}
public static void main(String[] args) {
WithInner wi = new WithInner();
InheritInner obj = new InheritInner(wi);
}
}更多java知识请关注java基础教程栏目。
以上是java內部類詳解（附相關面試題）的詳細內容。更多資訊請關注PHP中文網其他相關文章！
