版权所有，禁止匿名转载；禁止商业使用。
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, 没有构造方法。
匿名内部类隐式地继承了一个父类或者实现了一个接口。
匿名内部类使用得比较多，通常是作为一个方法参数。
OuterClass:
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();
}
}
TestOuterClass:
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());
}
}