java中内部类的使用

内部类是定义在另一个类中的类，内部类的作用如下：

1.内部类方法可以访问外围类的成员，包括私有数据而不用生成外部类的对象

主要原因是内部类和外部类存在逻辑上的关系：

第一：内部类对象的创建依赖于外部类对象（除了静态内部类）

第二：内部类对象持有指向外部类对象的引用

2.内部类可以很好的实现隐藏，普通类不允许有private和protect权限，而内部类可以

3.当想要定义一个回调函数而不想写大量代码时，用匿名内部类比较简洁

内部类主要包括一般内部类（成员内部类）、局部内部类、匿名内部类、静态内部类，他们之间的关系可以如下表示：



一.成员内部类

成员内部类是普通的内部类，它定义在另一个类的内部。成员内部类作为外部类的一个成员存在，与外部类的属性、方法并列

class Student{
String name;
int age;
public Student(String name){
this.name = name;
}
class Learn{
public void learnMath(){
System.out.println("Learn Math");
}
}
}

这里，Student类称为外部类，Learn类称为成员内部类，它可以直接调用外部类的属性和方法，无论是私有的还是静态的，如下：

class Student{
private String name = "小明";
static int age = 15;
public Student(){
new Learn().learnMath();    //实例化内部类
}
class Learn{
public void learnMath(){
System.out.println("Learn Math");
System.out.println(name);   //获取外部类私有属性
System.out.println(age);    //获取外部类静态属性
}
}
}
public class InnerClassDemo{
public static void main(String[] args){
new Student();         //实例化外部类
}
}

除了用这种方式调用执行，还可以通过如下方式执行：

class Student{
private String name = "小明";
static int age = 15;
class Learn{
public void learnMath(){
System.out.println("Learn Math");
System.out.println(name);
System.out.println(age);
}
}
}
public class InnerClassDemo{
public static void main(String[] args){
Student.Learn learn = new Student().new Learn();//可以将Student.Learn当成一个整体
learn.learnMath();
/*
或者通过这种方式访问
Student std = new Student();
Student.Learn learn = std.new Learn();
learn.learnMath();
*/
}
}

运行结果：
Learn Math
小明

15

Student.Learn learn = new Student().new Learn();

1.可以将Student.Learn看成整体，开头的Student是为了标明需要生成的内部类对象在哪个外部类当中
2.必须先有外部类的对象才能生成内部类的对象，因为内部类的作用就是为了访问外部类中的成员变量
注意：当外部类成员变量或方法与内部类成员变量方法同名时，注意调用外部类属性的写法

class Student{
private String name = "小明";
private int age = 15;                 //定义外部类变量
class Learn{
int age = 14;                 //定义内部类变量
public void learnMath(){
int age = 13;         //定义局部变量
System.out.println(age);
System.out.println(this.age);
System.out.println(Student.this.age);
}
}
}
public class InnerClassDemo{
public static void main(String[] args){
Student.Learn learn = new Student().new Learn();//可以将Student.Learn当成一个整体
learn.learnMath();
/*
或者通过这种方式访问
Student std = new Student();
Student.Learn learn = std.new Learn();
learn.learnMath();
*/
}
}

输出结果：

13

14

15

当没有同名局部变量或者内部变量时，可以用变量名直接访问外部变量，当有同名局部变量或同名内部变量时，直接通过变量名会访问局部变量，this.变量名会访问内部成员变量，要访问外部类变量需要通过 外部类.this.变量名
访问，当然，若此时外部成员变量声明为static，也可以用 外部类.变量名 直接访问外部变量。

二.局部内部类

局部内部类是定义在类的方法中的类。注意：

1.局部内部类就像是方法里面的一个局部变量一样，在局部内部类前不能用修饰符public和private、protected、static等修饰

2.可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的 

3.局部内部类中不可以定义静态变量和方法

局部内部类属于非静态内部类，非静态内部类除了要依靠外部类实例外，还要依赖内部类实例，而静态变量和方法是不需要构建类实例的，所以相矛盾，所以不能定义静态变量和方法

class Student{
private String name = "小明";
private int age = 15;  //定义外部类变量
public void print(final int x){
class Learn{
public void learnMath(){
System.out.println(x);
}
}
new Learn().learnMath();
}

}
public class InnerClassDemo{
public static void main(String[] args){
Student std = new Student();
std.print(10);

}
}

三.匿名内部类

匿名内部类即没有名字的内部类。表面上看起来它们似乎有名字，实际那不是它们的名字，而是它继承类或接口的名字

这里主要参考http://www.cnblogs.com/nerxious/archive/2013/01/25/2876489.html

注意：

1.正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写

2.但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口

abstract class Person{
public abstract void eat();
}
public class InnerDemo{
public static void main(String[] args){
Person p = new Person(){
public void eat(){
System.out.println("ead something");
}
};
p.eat();
}
}

匿名内部类是唯一一种没有构造器的类。正因为其没有构造器，所以匿名内部类的使用范围非常有限，大部分匿名内部类用于接口回调。一般来说，匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。

四.静态内部类

静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。可以将静态内部类看成一个外部类，或者看成独立的类，它不能使用外部类的非static成员变量或者方法，下面是其他类访问内部类方法的例子：

程序一：（错误程序）

class Outer{
private String info = "hello world";     //非静态变量
static class Inner{
public void print(){
System.out.println(info);//内部类获取外部类私有属性
}
}
}
public class StaticDemo04{
public static void main(String[] args){
new Outer.Inner().print();
}
}

该程序无法通过，因为静态内部类不能访问外部类非静态成员变量，因为在没有外部类对象的情况下仍然可以创建内部类的对象，而外部类的非static成员必须依附与具体的对象，这点矛盾了

程序二：（正确）

class Outer{
private static String info = "hello world";
static class Inner{
public void print(){
System.out.println(info);//内部类获取外部类私有属性
}
}
}
public class StaticDemo04{
public static void main(String[] args){
new Outer.Inner().print();
}
}

参考链接：
http://www.cnblogs.com/dolphin0520/p/3811445.html http://www.cnblogs.com/nerxious/archive/2013/01/24/2875649.html
http://www.cnblogs.com/nerxious/archive/2013/01/25/2876489.html http://blog.csdn.net/zhangjg_blog/article/details/20000769
《Java核心技术 卷一》