是什么
java语言中，把一个类定义到另外一个类的内部，在类里面的这个类就叫内部类，外面的类就叫外部类。这种情况下，这个内部类可以看做外部类的一个成员。
还有一种类被称为顶层类，指的是类定义代码不嵌套在其他类定义中的类。
分类
class outerClass{
static class innerClass{} //静态内部类
}
class outerClass{
class innerClass{} //成员内部类
}
class outerClass{
public void menberFunction{
static class innerClass{} /局部内部类
}
}
public class MyFrame extends Frame{//外部类
public MyFrame（）{
addWindowsLister（new WindowsAdapter（））{ //匿名内部类
public void windowsClosing（WindowEvent e）{
dispose（）； System.exit(0);
}
}
}
} 静态内部类是指被声明为static的内部类，它可以不依赖内部类而实例化，而通常的内部类需要实例化外部类，从而实例化。静态内部类不可以有与外部类有相同的类名。不能访问外部类的普通成员变量，但是可以访问静态成员变量和静态方法（包括私有类型）
一个 静态内部类去掉static 就是成员内部类，他可以自由的引用外部类的属性和方法，无论是静态还是非静态。但是不可以有静态属性和方法、
局部内部类 就是定义在一个代码块的内类,他的作用范围是所在代码块，是内部类中最少使用的一类型。局部内部类跟局部变量一样，不能被public ，protected，private以及static修饰，只能访问方法中定义final类型的局部变量。
在使用匿名内部类时，需要牢记以下几个原则。
1》内部类没有构造方法
2》匿名内部类不能定义静态成员，方法和类
3》匿名内部类不能是public protected private static
4》只能创建匿名内部类的一个实例
5》一个匿名内部类可以在new后面，这个匿名类必须继承一个父类或实现接口
6》因为匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效
————————————————————————————————————————
例子：
内部类
package cn.itcast.demo01;
public class Outer{
private int a =1;
//在外部类成员的位置定义内部类
class Inner{
public class void fun(){
System.out.println(a); //内部类可以使用外部类的成员。
}
}
}package cn.itcast.demo01;
public class Test{
public static void main(){
//调用外部类中的内部类的方法
Outer.Inner inn = new Outer().new Inner(); //创建内部类的对象的格式。
inn.fun(); // 1
}
class Inner{
System.out.println(a);
}
}注意：生成两个class文件：Outer.class、Outer$Inner.class。内部类编译完了也是class文件。
内部类中同名变量的调用
//1.java
package cn.itcast.demo01;
public class Outer(){
private int a = 1;
class Inner(){
private int a = 2;
public void fun(){
int a = 3;
System.out.println(a); //3
}
}
}
//2.java
package cn.itcast.demo02;
public class Outer(){
private int a = 1;
class Inner(){
private int a = 2;
public void fun(){
int a = 3;
System.out.println(this.a); //2
}
}
}
//3.java
package cn.itcast.demo01;
public class Outer(){
private int a = 1;
class Inner(){
private int a = 2;
public void fun(){
int a = 3;
System.out.println(Ouer.this.a); //1
}
}
}局部内部类，定义在成员方法里面
package cn.itcast.demo01;
public class Outer(){
public void out(){
class Inner{
public void fun(){
System.out.println("aaaa");
}
}
Inner inn = new Inner(); //在方法内部使用这个类。否则在main中没法使用这个类。
inn.fun();
}
}package cn.itcast.demo01;
public class Test{
Outer o = new Outer();
o.out(); //aaaa
}匿名内部类
//Smoking.java 正常接口使用方法
package cn.itcast.demo01;
public interface Smoking{
public abstract void smoking();
}
//Person.java
public class Person implements Smoking{
public void smoking(){
System.out.println("aaaa");
}
}
//Test.java
public class Test{
public static void main(){
Person p = new Person();
p.smoking(); //aaaa
}
}
//分析。这么写太麻烦。希望：定义实现类、重写方法、创建实现类对象一步搞定。//Smoking.java 匿名内部类使用方法
package cn.itcast.demo01;
public interface Smoking{
public abstract void smoking();
}
//Test.java
public class Test{
public static void main(){
new Smoking(){
public void smoking(){
System.out.println("aaaa");
}
}.smoking();
}
}
//输出结果：aaaa 匿名内部类的使用举例
//Animal.java
package cn.itcast.demo01;
public interface Animal{
public abstract void eating();
public abstract void sleeping();
}
//Test.java
public class Test{
public static void main(){
Animal a = new Animal(){
public void eating(){
System.out.println("eating...");
}
public void sleeping(){
System.out.println("sleeping...");
}
};
a.eating();
a.sleeping();
}
}参考：