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

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();
 }