java内部类

/**
 * @author wangcheng
 * @date 17/12/20
 */
public class Outer {

    /*
        Outer外部类的反编译结果,可以发现对于私有变量data的访问实际上是通过access$000()方法进行的
        public class com.thinkjoy.InnerClass.Outer {
          public com.thinkjoy.InnerClass.Outer();
          public void local(java.lang.String, java.lang.String);
          public static void main(java.lang.String[]);
          static int access$000(com.thinkjoy.InnerClass.Outer);
        }

        static int access$100(com.thinkjoy.InnerClass.Outer);
            Code:
               0: aload_0
               1: getfield      #1                  // Field data:I
               4: ireturn

        aload_0: 对static方法来说获取第一个参数,对非static方法来说是this
        getfield: 获取Outer的data字段
        ireturn: 返回int类型
     */

    // 为什么内部类可以访问外部类的私有变量?
    // 首先,在编译后,该内部类和外部类是两个独立的文件Outer.class和Outer$MemberInner.class
    // 那么,两个独立类怎么可以访问到自己的成员变量,
    // 一种方式是直接在类内部--这种显然是不对的,因为已经编译成两个类文件了
    // 第二种方式是通过该类的对象访问,但是对象只能访问可见的成员变量,如protected修饰的变量,只能在同包和子类中通过对象直接访问,
    // 那么怎么访问private呢?
    // 通过查看反编译文件,得知Outer.class中多出了access$000(Outer)这么一个静态方法,这个方法返回值就是data
    // 如步骤③,内部类直接可以访问外部类的data,实际执行的语句是这样的 System.out.println(Outer.access$000(this$0));
    //
    // 对于access$000方法不考虑传入的外部类实例是否可以在其他类中获取该实例的私有成员变量
    // 访问修饰符是代码层面的可见性控制,而access$000是编译器直接生成的字节码,故可以访问

    private int data = 0;

    static String str = "www";

    //成员内部类,访问修饰符可以是private,protected,default,public
     class MemberInner {
        //static int i = 0; 不能有static局部变量,因为成员内部类要在外部类实例创建之后才能创建,当内部类为讲台局部内部类的时候是可以的

        private int count = 0;
        /*
            class com.thinkjoy.InnerClass.Outer$MemberInner {
              final com.thinkjoy.InnerClass.Outer this$0;
              com.thinkjoy.InnerClass.Outer$MemberInner(com.thinkjoy.InnerClass.Outer);
              void print();
              static int access$000(com.thinkjoy.InnerClass.Outer$MemberInner);
                 Code:
                   0: aload_0
                   1: getfield      #1                  // Field count:I
                   4: ireturn
            }
         */

        /*
             Outer.MemberInner memberInner = new Outer().new MemberInner() {
                //nothing to do
             };
             memberInner.print();
             当在其他类中进行执行上述代码,不会输出任何东西,
         */

        void print() {
            //③可以访问外部类的私有变量
            System.out.println(data);
            System.out.println(str);
        }


        class InnerMemberInner{
            /*
                class com.thinkjoy.InnerClass.Outer$MemberInner$InnerMemberInner {
                  final com.thinkjoy.InnerClass.Outer$MemberInner this$1;
                  com.thinkjoy.InnerClass.Outer$MemberInner$InnerMemberInner(com.thinkjoy.InnerClass.Outer$MemberInner);
                  void innerPrint();
                       Code:
                           0: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
                           3: aload_0
                           4: getfield      #1                  // Field this$1:Lcom/thinkjoy/InnerClass/Outer$MemberInner;
                           7: invokestatic  #4                  // Method com/thinkjoy/InnerClass/Outer$MemberInner.access$000:(Lcom/thinkjoy/InnerClass/Outer$MemberInner;)I
                          10: invokevirtual #5                  // Method java/io/PrintStream.println:(I)V
                          13: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
                          16: aload_0
                          17: getfield      #1                  // Field this$1:Lcom/thinkjoy/InnerClass/Outer$MemberInner;
                          20: getfield      #6                  // Field com/thinkjoy/InnerClass/Outer$MemberInner.this$0:Lcom/thinkjoy/InnerClass/Outer;
                          23: invokestatic  #7                  // Method com/thinkjoy/InnerClass/Outer.access$100:(Lcom/thinkjoy/InnerClass/Outer;)I
                          26: invokevirtual #5                  // Method java/io/PrintStream.println:(I)V
                          29: return
                }
            */

            void innerPrint(){
                System.out.println(count);
                System.out.println(data);
            }
        }
    }

    //局部内部类,不允许有修饰符,类似局部变量
    public void local(final String name, String age) {


        //①定义在代码块中,只能在代码块中访问
        //{
        //  class LocalInner1 {
        //
        //  }
        //}

        //②编译报错,找不到该类的符号
        //new LocalInner(){
        //
        //};

        //定义在方法中,可以在方法中访问,且实例化的代码必须在定义之后,否则无法访问,同②
        class LocalInner {
            /*
             该局部内部类的
             class com.thinkjoy.InnerClass.Outer$1LocalInner {
                final java.lang.String val$name;
                final com.thinkjoy.InnerClass.Outer this$0;
                com.thinkjoy.InnerClass.Outer$1(com.thinkjoy.InnerClass.Outer, java.lang.String);
                public void print();
             }
             */

            public void print() {
                // name是外部类local方法的参数,且name必须为final,
                // 为什么需要是final?
                // 可以发现,上面的注释是该局部内部类的反编译代码,
                // 发现编译器将该类重新生成一个单独的Outer$1LocalInner类,与Outer同包,
                // 在该类中,编译器新增了一个final的成员变量val$name,也就是Outer的local参数name的备份,
                // 假如local的name不是final的,也就是name是可以更改的,那么是不是局部内部类中的val$name也需要做修改
                // 所以,编译器规定,local的name是final的,不可修改,val$name也就是final(因为name不会变了)
                System.out.println(name);
            }
        }

        //匿名内部类,没有名字的内部类,其实是继承Outer$1LocalInner类,编译器生成的默认名字是Outer$1
        LocalInner localInner = new LocalInner() {

            /*
             该匿名内部类的
             class com.thinkjoy.InnerClass.Outer$1 extends com.thinkjoy.InnerClass.Outer$1LocalInner {
                final java.lang.String val$name;
                final com.thinkjoy.InnerClass.Outer this$0;
                //包可见的构造方法,可以设置外部类的引用this$0与外部类local方法参数name的备份
                com.thinkjoy.InnerClass.Outer$1(com.thinkjoy.InnerClass.Outer, java.lang.String);
                public void print();
             }
             */

            @Override
            public void print() {
                //name是外部类local方法的参数,且name必须为final
                System.out.println(name);
                System.out.println(data);
            }
        };

        localInner.print();

    }


    //嵌套内部类--staic修饰的内部类
    static class StaticInner {
        //可以有静态的成员变量,并且可以有修饰符
        private static int data = 0;
    }

    public static void main(String[] args) {

        // ①成员内部类的修饰符为private,在当前类中是可以访问内部类的,但是在其他类中是不能访问内部类的
        // 同理,其他访问修饰符是跟成员变量的修饰符的作用是一样的
        MemberInner memberInner = new Outer().new MemberInner();

        //②嵌套内部类
       // System.out.println(StaticInner.data);//可以直接访问,并且可以根据修饰符调整可见性

    }
}