什么是内部类：
定义在其他类（outer class）中的类被称作内部类。内部类可以有访问修饰服，甚至可以被标记为 abstract 或 final。 内部类与外部类实例有特殊的关系，这种关系允许内部类访问外部类的成员，也包括私有成员。
内部类分为以下四种：
内部类（inner class）
局部内部类
匿名内部类
静态嵌套类
为什么要使用内部类：
在《Think in Java》中有这样一句话：
使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。
在我们程序设计中有时候会存在一些使用接口很难解决的问题，这个时候我们可以利用内部类提供的、可以继承多个具体的或者抽象的类的能力来解决这些程序设计问题。可以这样说，接口只是解决了部分问题，而内部类使得多重继承的解决方案变得更加完整。
举例说明：
public interface Father {
}
public interface Mother {
}
public class Son implements Father, Mother {
}
public class Daughter implements Father{
class Mother_ implements Mother{
}
} 其实对于这个实例我们确实是看不出来使用内部类存在何种优点，但是如果Father、Mother不是接口，而是抽象类或者具体类呢？这个时候我们就只能使用内部类才能实现多重继承了。
其实使用内部类最大的优点就在于它能够非常好的解决多重继承的问题，但是如果我们不需要解决多重继承问题，那么我们自然可以使用其他的编码方式，但是使用内部类还能够为我们带来如下特性
以下（摘自《Think in java》）
1、内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立。
2、在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类。
3、创建内部类对象的时刻并不依赖于外围类对象的创建。
4、内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。
5、内部类提供了更好的封装，除了该外围类，其他类都不能访问。
内部类语法：
public class OuterClass {
private String name ;
private int age;
/**省略getter和setter方法**/
public class InnerClass{
public InnerClass(){
name = "chenssy";
age = 23;
}
public void display(){
System.out.println("name：" + getName() +" ;age：" + getAge());
}
}
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
OuterClass.InnerClass innerClass = outerClass.new InnerClass();
innerClass.display();
}
}
Output：
name：chenssy ;age：23
- 在这个应用程序中，我们可以看到内部了InnerClass可以对外围类OuterClass的属性进行无缝的访问，尽管它是private修饰的。这是因为当我们在创建某个外围类的内部类对象时，此时内部类对象必定会捕获一个指向那个外围类对象的引用，只要我们在访问外围类的成员时，就会用这个引用来选择外围类的成员。
- 其实在这个应用程序中我们还看到了如何来引用内部类：引用内部类我们需要指明这个对象的类型：OuterClasName.InnerClassName。同时如果我们需要创建某个内部类对象，必须要利用外部类的对象通过.new来创建内部类：OuterClass.InnerClass innerClass = outerClass.new InnerClass();。
- 同时如果我们需要生成对外部类对象的引用，可以使用OuterClassName.this，这样就能够产生一个正确引用外部类的引用了。当然这点实在编译期就知晓了，没有任何运行时的成本。
public class OuterClass {
public void display(){
System.out.println(“OuterClass…”);
}
public class InnerClass{
public OuterClass getOuterClass(){
return OuterClass.this;
}
}
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
OuterClass.InnerClass innerClass = outerClass.new InnerClass();
innerClass.getOuterClass().display();
}
}
Output:
OuterClass
到这里了我们需要明确一点，内部类是个编译时的概念，一旦编译成功后，它就与外围类属于两个完全不同的类（当然他们之间还是有联系的）。对于一个名为OuterClass的外围类和一个名为InnerClass的内部类，在编译成功后，会出现这样两个class文件：OuterClass.class和OuterClass$InnerClass.class。
在Java中内部类主要分为成员内部类、局部内部类、匿名内部类、静态内部类。
成员内部类：
成员内部类也是最普通的内部类，它是外围类的一个成员，所以他是可以无限制的访问外围类的所有 成员属性和方法，尽管是private的，但是外围类要访问内部类的成员属性和方法则需要通过内部类实例来访问。
在成员内部类中要注意两点，第一：成员内部类中不能存在任何static的变量和方法；第二：成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类。
推荐使用getxxx()来获取成员内部类，尤其是该内部类的构造函数无参数时 。
public class OuterClass {
private String str;
public void outerDisplay(){
System.out.println("outerClass...");
}
public class InnerClass{
public void innerDisplay(){
//使用外围内的属性
str = "chenssy...";
System.out.println(str);
//使用外围内的方法
outerDisplay();
}
}
/*推荐使用getxxx()来获取成员内部类，尤其是该内部类的构造函数无参数时 */
public InnerClass getInnerClass(){
return new InnerClass();
}
public static void main(String[] args) {
OuterClass outer = new OuterClass();
OuterClass.InnerClass inner = outer.getInnerClass();
inner.innerDisplay();
}
}
--------------------
chenssy
outerClass局部内部类
局部内部类被定义在外部类的方法当中。
如果你想使用内部类，必须同一方法中实例化内部类
只有 abstract 和 final 这两个修饰符被允许修饰局部内部类
只有在方法的局部变量被标记为 final 或 局部变量是 effectively final的， 内部类才能使用它们。
什么是 effectively final？ “Starting in Java SE 8, a local class can access local variables and parameters of the enclosing block that are final or effectively final. A variable or parameter whose value is never changed after it is initialized is effectively final.” 因此当变量或参数在初始化之后，值再也没有改变过，那么就说明该变量或参数是 effectively final。
//Top level class definition
class MyOuterClassDemo {
private int x= 1;
public void doThings(){
String name ="local variable"; // name is effectively final
// inner class defined inside a method of outer class
class MyInnerClassDemo {
public void seeOuter() {
System.out.println("Outer Value of x is :" + x);
System.out.println("Value of name is :" + name);
} //close inner class method
} // close inner class definition
MyInnerClassDemo inner = new MyInnerClassDemo();
inner.seeOuter();
} //close Top level class method
public static void main(String[] args){
MyOuterClassDemo outer = new MyOuterClassDemo();
outer.doThings();
}
} // close Top level class
Output:
Outer Value of x is :1
Value of name is :local variable
匿名内部类：
匿名内部类有以下特点：
没有名字
只能被实例化一次
通常被声明在方法或代码块的内部，以一个带有分号的花括号结尾
因为没有名字，所以没有构造函数
不能是静态的（static)
为什么要使用匿名类，我们先看一个例子：
abstract class Animal {
abstract void play();
}
class Dog extends Animal{
void play(){
System.out.println("play with human");
}
}
class Demo{
public static void main(String[] args){
Animal d = new Dog();
d.play();
}
}
Output: play with human如果此处的 Dog 类只使用了一次，那么单独定义一个Dog类是否会显得有点麻烦？ 这个时候我们可以引入匿名类：
abstract class Animal {
abstract void play();
}
class Person{
public static void main(String[] args){
Animal d = new Animal(){
void play(){
System.out.println("play with human");
}
};
d.play();
}
}
Output: play with human匿名类的一个重要作用就是简化代码。
匿名类的常用场景：
1.事件监听：
普通的实现方式：
public class WindowClosingAdapter extends WindowAdapter {
public void windowClosing( WindowEvent e ) {
System.exit(0);
}
}
addWindowListener( new WindowClosingAdapter() );匿名内部类的实现方式：
addWindowListener(
new WindowAdapter() {
public void windowClosing( WindowEvent e ) {
System.exit(0);
}
});2.Thread 类的匿名内部类实现
public class Demo {
public static void main(String[] args) {
Thread t = new Thread() {
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.print(i + " ");
}
}
};
t.start();
}}
Runnable 接口的匿名内部类实现
public class Demo {
public static void main(String[] args) {
Runnable r = new Runnable() {
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.print(i + " ");
}
}
};
Thread t = new Thread(r);
t.start();
}
}
匿名内部类需要注意的地方：
1、 匿名内部类是没有访问修饰符的。
2、 new 匿名内部类，这个类首先是要存在的。如果我们将那个InnerClass接口注释掉，就会出现编译出错。
3、 注意getInnerClass()方法的形参，第一个形参是用final修饰的，而第二个却没有。同时我们也发现第二个形参在匿名内部类中没有使用过，所以当所在方法的形参需要被匿名内部类使用，那么这个形参就必须为final。
4、 匿名内部类是没有构造方法的。因为它连名字都没有何来构造方法。
静态嵌套类
Static可以修饰成员变量、方法、代码块，其他它还可以修饰内部类，使用static修饰的内部类我们称之为静态内部类，不过我们更喜欢称之为嵌套内部类。静态内部类与非静态内部类之间存在一个最大的区别，我们知道非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围内，但是静态内部类却没有。没有这个引用就意味着：
1、 它的创建是不需要依赖于外围类的。
2、 它不能使用任何外围类的非static成员变量和方法。class Outer{
static class Nested{}
}
静态嵌套类可以被这样实例化：
class Outer{// outer class
static class Nested{}// static nested class
}
class Demo{
public static void main(string[] args){
// use both class names
Outer.Nested n= new Outer.Nested();
}
}参考博客：
http://liuzxc.github.io/blog/java-advance-02/
http://blog.csdn.net/chenssy/article/details/13024951
