1:成员内部类Member Inner Class
在一个类中使用内部类，可以在内部类中直接存取其所在类的任何成员变量和方法。
在外部类里面创建成员内部类的实例：
this.new Innerclass();或者new InnerClass();
在外部类之外创建内部类的实例：
(new Outerclass()).new Innerclass();
在内部类里访问外部类的成员：
Outerclass.this.member
2:静态内部类Static Inner Class
静态内部类只能使用外部类的静态成员和方法，而不能使用非静态成员和方法。
在外部类里面创建成员内部类的实例：
new Innerclass();
在外部类之外创建内部类的实例：
new Outerclass. Innerclass();
3:局部内部类Local Inner Class
局部内部类在方法里面，跟局部变量一样，不能有public，protected，private等关键词修饰，它不能访问外部类中的成员变量和方法，只能访问其所在方法里面的final变量。
4:匿名内部类Anonymous Inner Class
匿名内部类就是没有名字的局部内部类，不使用关键字class, extends, implements, 没有构造方法。
匿名内部类隐式地继承了一个父类或者实现了一个接口。
匿名内部类使用得比较多，通常是作为一个方法参数。
测试：
package javase.innerclass;
public class OuterClass {
static int x=0;
int y=0;
public class MemberInnerClass{
private int y=0;
MemberInnerClass(){
y=5;
}
public void fun(){
System.out.println("fun function from member inner class");
//调用内部类中的方法，如果内部类不存在此方法。
//而外部类中存在，则调用的是外部类中的方法。
printY(10);
//调用外部类中的方法
OuterClass.this.printY();
}
public void printY(int y){
System.out.println("printY function from member inner class");
//输出通过参数传进来的y
System.out.println("函数参数y="+y);
//输出内部类中的属性y
System.out.println("内部类中属性y="+this.y);
//输出外部类中的属性y
System.out.println("外部类中属性y="+OuterClass.this.y);
}
}
public void printY(){
System.out.println("printY function from outter class");
//在外部类里面新建成员内部类的实例,也可以这样写：
//MemberInnerClass innerClass=new MemberInnerClass();
MemberInnerClass innerClass=this.new MemberInnerClass();
//在外部类里面新建静态内部类的实例
StaticInnerClass staticClass=new StaticInnerClass();
//输出成员内部类中的成员变量
System.out.println("成员内部类属性y="+innerClass.y);
//输出外部内中的成员变量
System.out.println("外部类属性y="+y);
//输出静态内部类中的成员变量
System.out.println("静态内部类属性x="+staticClass.x);
}
public static class StaticInnerClass{
private int x=10;
public void printX(){
System.out.println("printX function from static inner class");
//输出内部类中的变量
System.out.println("静态内部类属性x="+x);
//只能调用外部类的静态成员和方法
System.out.println("外部类属性x="+OuterClass.x);
}
}
public void testLocalInnerClass(){
final int k=1;
//局部内部类
class LocalInnerClass{
public void printK(){
System.out.println("printK function from local inner class");
//只能访问方法中的final变量
System.out.println("局部内部类所在的方法中的变量k="+k);
}
}
LocalInnerClass localClass=new LocalInnerClass();
localClass.printK();
}
}
package javase.innerclass;
import java.util.Date;
public class TestOuterClass {
public static void main(String args[]){
OuterClass out=new OuterClass();
System.out.println("=====成员内部类==========");
//在外部类外实例化局部内部类对象
OuterClass.MemberInnerClass in= out.new MemberInnerClass();
in.fun();
System.out.println("=====静态内部类==========");
//在外部类外实例化静态内部类对象
OuterClass.StaticInnerClass staticInnerClass=new OuterClass.StaticInnerClass();
staticInnerClass.printX();
System.out.println("=====局部内部类==========");
//局部内部类
out.testLocalInnerClass();
System.out.println("=====匿名内部类==========");
//匿名内部类,相当于继承Date类，并且重写了toString方法
System.out.println(new Date(){
private static final long serialVersionUID = 1L;
@Override
public String toString(){
return "hello "+super.toString();
}
}.toString());
}
}