java四种内部类（静态内部类，成员内部类，方法内部类，匿名内部类）详解

**简而言之，内部类的目的在于方便使用外部类的方法及域，为外部类的实现提供服务。可分为四种内部类（静态内部类，成员内部类，方法内部类，匿名内部类）。下面是具体使用方法

1、静态内部类的使用方法

/** * 测试静态内部类 * @author Hunter */import test.OuterClass01.StaticNestedClass;public class Demo01 {    public static void main(String[] args) {        //在不相关类中，可以直接创建静态内部类的对象（不需要依赖外部类的对象)        OuterClass01.StaticNestedClass ocsnc = new OuterClass01.StaticNestedClass();        StaticNestedClass snc = new StaticNestedClass();//直接创建需要导入        //直接调用静态内部类的静态方法        OuterClass01.StaticNestedClass.innerMethod();    }}class OuterClass01{    static int a = 10;    int b = 20;    private static void outerMethod(){        System.out.println(a);    }    //定义静态内部类,与外部内的静态域同一个级别    static class StaticNestedClass{        //静态内部类可以包含静态域与非静态域        int c = 10;        static int d = 20;        //静态内部类可以直接使用外部类的静态域和静态方法，不可以使用外部类的非静态域和方法        static public  void innerMethod(){            a = 20;            outerMethod();        }    }}

2、成员内部类的使用方法

/** * 测试成员内部类 * @author Hunter */import java.util.Date;public class Demo02 {    public static void main(String[] args) {        //在不相关类中建立成员内部类的对对象的方法，必须先建立外部类对象        OuterClass02 oc = new OuterClass02();        OuterClass02.NestedClass nc = oc.new NestedClass();        nc.innerMethod();    }}class OuterClass02{    private static int a = 10;    private int b = 20;    //定义一个成员内部类，相当于外部类的一个普通域    public class NestedClass{        //成员内部类只能拥有非静态域和方法，或者加了final声名的编译时的常量静态值        //采用这种机制的原因在于,假设定义了static NestedClass nc = new NestedClass();        //在不相关类中就可以利用 OuterClass02.NestedClass.nc来访问成员内部类的对象,        //这样就完全脱离了外部类对象，不符合成员内部类初衷.        int c = 10;//      static int d = 20;//不行        static final int e = 30; //可以//      static final Date date = new Date();//不行        public void innerMethod(){            //成员内部类可以直接访问外部类的域及方法（包括private），使用OuterClass02.this表示外部类；            //这表明成员内部类的对象的存在必须依赖于外部类对象            OuterClass02.this.b = 30;             System.out.println(OuterClass02.this);            System.out.println(this);        }    }}

3、方法内部类的使用方法

/** * 测试方法内部类（局部内部类） * @author Hunter * */public class Demo03 {    public static void main(String[] args) {        OuterClass03 oc = new OuterClass03();        oc.method();    }}class OuterClass03{    public void method(){        int a = 10;        final int b = 10;        //定义一个方法内部类（局部内部类），方法内部类与方法中的域属于一个级别，因此不能加modifier        //方法内部类只能在定义的方法中使用        class MethodNestedClass{        //方法内部类中只能包含非静态域和方法            int c = 10;//          static int d = 10;//不行            public void InnerMethod(){                //方法内部类不能访问定义它的方法的局部变量，除非这个变量被声名成final                //编译器做了优化，将外部方法的域转化成常量                System.out.println(a);//编译器通过，不建议这么使用，早期编译器无法通过//              a = 20;//不行                System.out.println(b);//final修饰可以引用，不能修改值    //采用此机制的原因在于，方法（通过方法针压栈）的生命周期与方法内部类（存在堆中）的生命周期不一致            }        }        MethodNestedClass mnc =new MethodNestedClass();        mnc.InnerMethod();    } }

4、匿名内部类的使用方法

/** * 测试匿名内部类 * @author zxt * */public class Demo04 {    public static void main(String[] args) {        new OuterClass04().mehtod();    }}class OuterClass04{    //测试创建匿名内部类的三种方式    //值得注意的是，匿名内部类需要注意其属于方法内部类还是成员内部类，符合相应的特性    public void mehtod(){        //接口式创建匿名内部类,new一个实现该接口的类        Runnable run = new Runnable(){            @Override            public void run() {            }        };        //继承式创建匿名内部类（可继承抽象类或非抽象类），new一个继承该类的新类        AbstractClass ac =new AbstractClass(){            @Override            public void sayHello() {                 System.out.println("Hello!");            }        };        ac.sayHello();        //参数式创建匿名内部类        getAbstractClass(new AbstractClass(){            @Override            public void sayHello() {                 System.out.println("Hello!");            }        });    }    private void getAbstractClass(AbstractClass ab){        ab.sayHello();    }} abstract class  AbstractClass{     public abstract void sayHello(); }