内部类是指在一个外部类的内部再定义一个类，是一个编译时的概念。一旦编译成功，内部类与其外部类就会成为全然不同的两类，仅仅是内部类的前面会冠以外部类的类名和$符号，如一个outer类内部定义了一个inner的内部类，那么编译完毕后会生成outer.class和outer$inner.class两个类，因此内部类的成员变量与方法能够与外部类同样。

从内部类的定义上来看。事实上内部类严重破坏了良好的代码结构。那么为什么还要使用内部类呢？由于内部类能够任意使用外部类的成员变量（包含私有的）而不用生成外部类对象，这也是内部类的唯一长处。

内部类分为成员内部类、局部内部类、静态内部类和匿名内部类。以下针对各个内部类进行介绍：

作为外部类的一个成员存在，与外部类的属性、方法并列。成员内部类中能够訪问外部类的全部成员，当外部类的变量与内部类的变量名反复时，使用外部类名.this.变量名能够对外部类的变量进行调用。假设没有反复时可直接使用变量名进行调用。在普通外部类方法中訪问静态内部类可new出成员内部类对象进而直接调用当中的方法，而在静态外部类方法中须要先new出外部类对象，再调用外部类对象名.new 内部类的方式来获得成员内部类对象。

成员内部类中不能定义静态变量，由于成员内部类须要先创建了外部类，才干创建它自己的。

成员内部类能够使用外部类的私有成员和属性。同一时候其在外部类中定义了不可訪问的属性，这样就在外部类中实现了比外部类的private还要小的訪问权限。

演示样例代码例如以下：

/*** * @ClassName: MemberInnerClass* @Description: 成员内部类* @author ADAM* @date 2014年7月25日 上午9:20:28**/
public class MemberInnerClass {private int i = 0;public class Inner {// 成员内部类可加权限修饰符int i = 3;public void print() {System.out.println(i);// 输出为内部类的i。值为3System.out.println(this.i);// 输出为内部类的i，值为3System.out.println(MemberInnerClass.this.i);// 输出外部类的i，值为0}}public void print() {(new Inner()).print();// 外部类普通方法调用成员内部类直接new出内部类进行调用}public static void main(String[] args) {((new MemberInnerClass()).new Inner()).print();// 外部类静态方法中调用成员内部类首先new出外部类然后new出内部类进行调用}
}

（2）局部内部类

/*** * @ClassName: LocalInnerClass * @Description: 局部内部类* @author ADAM* @date 2014年7月25日 上午10:36:26 **/
public class LocalInnerClass {private int j = 3;private int i = 2;public void test() {MemberInnerClass memberInnerClass = new MemberInnerClass();
// 若要訪问其它类中的成员内部类仅仅能当该成员内部类的修饰符为public才可
// 否则编译错误，即成员内部类能够再类内部实现比private还要小的权限memberInnerClass.new Inner();final int i = 0;class Inner {// 此处不得加上private等修饰符，否则编译错误int i = 1;public void print() {System.out.println(j);饰符。否则编译错误System.out.println(i);// 此时输出局部内部类的i,外部方法中的变量仅仅能通过传參的形式进行调用System.out.println(LocalInnerClass.this.i);// 此时输出的是外部类中的i}}Inner inner = new Inner();// 局部内部类仅仅能在方法内实例化并进行调用inner.print();}public static void main(String[] args) {(new LocalInnerClass()).test();}
}

局部内部类不仅能够定义在方法中还能够定义在作用域内。下面提供两个Thinking in Java的样例

定义在方法内：

public class Parcel4 { public Destination destination(String s) { class PDestination implements Destination { private String label; private PDestination(String whereTo) { label = whereTo; } public String readLabel() { return label; } } return new PDestination(s); } public static void main(String[] args) { Parcel4 p = new Parcel4(); Destination d = p.destination("Tasmania"); }
} <span style="line-height: 1.3em; font-family: 'Courier New', monospace; background-color: inherit;"> </span>

定义在作用域里：

public class Parcel5 { private void internalTracking(boolean b) { if (b) { class TrackingSlip { private String id; TrackingSlip(String s) { id = s; } String getSlip() { return id; } } TrackingSlip ts = new TrackingSlip("slip"); String s = ts.getSlip(); } } public void track() { internalTracking(true); } public static void main(String[] args) { Parcel5 p = new Parcel5(); p.track(); }
} 

局部内部类也像别的类一样进行编译，仅仅是作用域有所不同。仅仅在该方法或者条件的作用域内才干使用。出了这些作用域则无法被使用。

（3）静态内部类

静态内部类也称为嵌套内部类，定义在类中，不论什么方法外。用static定义，静态内部类中能够定义静态或非静态的成员，其可用public、private等修饰符修饰，一般使用public修饰。方便调用，其仅仅能訪问外部类中的静态成员。外部类訪问静态内部类中的静态成员时直接使用内部类.静态成员，訪问静态内部类的非静态成员时先实例化静态内部类再通过对象訪问。

生成一个静态内部类不须要外部类对象成员。这是与成员内部类的差别，同一时候普通内部类不能有static方法和属性，也不能包括嵌套类，静态内部类的对象能够直接生成：外部类.内部类 对象名= new 外部类.内部类()就可以

注意：当类与接口（或者接口与接口）发生方法命名冲突时，必须使用内部类来实现。

用接口不能全然地实现多继承，用接口配合内部类才干实现真正的多继承。

演示样例代码例如以下：

/*** * @ClassName: StaticInnerClass * @Description: 静态内部类* @author ADAM* @date 2014年7月25日 上午10:37:04 **/
public class StaticInnerClass {private int i = 1;public static int j = 1;public int k = 0;public static class Inner {private int i = 0;private static int j = 0;// 可定义静态与非静态成员public static void print() {
//          System.out.println(k);// 编译错误，不得调用外部类中的非静态成员System.out.println(new StaticInnerClass().i);//訪问外部类中的非静态成员变量须要先实例化外部类System.out.println(j);System.out.println(new StaticInnerClass().j);// 静态内部类使用外部类中的静态成员}}public static void main(String[] args) {Inner.print();// 外部类静态方法或者非静态方法调用静态内部类中的静态成员时直接内部类名.成员就可以StaticInnerClass.Inner inner = new StaticInnerClass.Inner();// 静态内部类的实例化不须要先实例化外部类System.out.println(inner.i);// 訪问静态内部类中的非静态成员时须要先实例化静态内部类}
}

通过内部类实现多继承演示样例代码例如以下：

/*** * @ClassName: Pencil * @Description: 笔类* @author ADAM* @date 2014年7月25日 上午10:42:59 **/
public abstract class Pencil {public abstract void write();
}
/*** * @ClassName: Eraser * @Description: 橡皮擦类* @author ADAM* @date 2014年7月25日 上午10:43:28 **/
public abstract class Eraser {public abstract void erase();
}
/*** * @ClassName: PencilWithEraser * @Description: 多继承类* @author ADAM* @date 2014年7月25日 上午10:43:53 **/
public class PencilWithEraser {private MyPencil pencil = new MyPencil();private MyEraser eraser = new MyEraser();private class MyPencil extends Pencil {//继承笔类@Overridepublic void write() {System.out.println("To Write");}}private class MyEraser extends Eraser {//继承橡皮擦类@Overridepublic void erase() {System.out.println("To Erase");}}// 本类自己的方法。调用继承类中的方法public void write() {pencil.write();}public void erase() {eraser.erase();}public static void main(String[] args) {PencilWithEraser pencilWithEraser = new PencilWithEraser();pencilWithEraser.write();pencilWithEraser.erase();}
}

（4）匿名内部类

演示样例代码例如以下：

/*** * @ClassName: AnonymousInnerClass * @Description: 匿名内部类* @author ADAM* @date 2014年7月25日 上午10:38:25 **/
public class AnonymousInnerClass {public void click(OnClickListener onClickListener) {System.out.println("click,click");}public static void main(String[] args) {AnonymousInnerClass anonymousInnerClass = new AnonymousInnerClass();anonymousInnerClass.click(new OnClickListener() {// 直接new出匿名内部类，不须要保存对象。一般用于继承其它类或是实现接口@Overridepublic void onClick() {System.out.println("Inner Click");}});}
}

四、总结

因为眼下还是处于学习阶段，对于内部类的使用最多的也是成员内部类和匿名内部类。所以对于诸如非常仔细地去区分各个内部类的使用场景以及涉及到的更小的訪问权限的作用等方面体会并非非常深刻，之后有更进一步的学习会补上，也希望看到这篇博文的朋友假设有一些其它的见解或者补充或者是推荐学习的资料也能够提出来，这篇博文也是借鉴网上各位大神以及百科的相关资料，再自己手动编码验证总结果出，感恩节你大神，谢谢。

版权声明：本文博客原创文章。博客，未经同意，不得转载。