java11-member-inner-class-compilation

We will discuss how member inner classes are compiled.

Reference: https://www.amazon.com/Java-Language-Features-Modules-Expressions/dp/1484233476

preview

A member inner class is defined inside a class the same way a member field or a member method. It could be private, package-level, protected, public.

Naming convention: <outer-class-name>$<member-inner-class-name>

decompiler configuration

1. Inner classes are hidden by default in Intellij explorer.
2. Configuration of javap decompiler is child's play:
   1. ctrl + alt + s (Settings)
   2. external tools
   3. + (plus)
      • Program: $JDKPath$\bin\javap.exe
      • Arguments: -c $FileClass$
        • -c Prints out disassembled code
      • Working directory: $OutputPath$
3. Using javap from context menu:
   • right click on the class -> External Tools -> javap
4. Using javap from terminal: "java_home\bin\javap.exe" -c path_to_compiled\Outer$Inner.class

project description

1. The easiest example, package: easy

   class Outer {
       class Inner {
       }
   }
   

   is compiled to two classes:
   • Outer$Inner.class

     class Outer$Inner {
     
         final Outer this$0;
         
         Outer$Inner(Outer outer) {
             this$0 = outer;
             super();
         }
     }
     

     • final field for Outer instance was added
     • note that super() is after setting the field
     • a one-param constructor that accepts Outer is inserted during compilation
   • Outer.class

     class Outer {
         Outer() {
         }
     }
     

     • the coupling between Outer and Inner is removed in the compilation
2. Inner class has constructor, package: constructor

   class Outer {
       class Inner {
           Inner(String s) {
           }
       }
   }
   

   is compiled to two classes:
   • Outer$Inner

     class Outer$Inner {
     
         final Outer this$0;
         
         Outer$Inner(Outer outer, String s) {
             this$0 = outer;
             super();
         }
     }
     

     • additional param (Outer) was added to the existing constructor
   • Outer.class same as (1.)
3. accessing private fields, package: accessing.priv

   class Outer {
   
       private String s = "outer";
   
       class Inner {
           String getS() {
               return s;
           }
       }
   }
   

   is compiled to two classes:
   • Outer.class

     class Outer {
         private String s = null;
         
         Outer() {
             s = "outer";
         }
         
         static String access$000(Outer outer) {
             return outer.s;
         }
     }
     

     • static method for extracting private field (flagged by compiler - we don't have direct access)
   • Outer$Inner

     class Outer$Inner {
     
         final Outer this$0;
         
         Outer$Inner(Outer outer) {
             this$0 = outer;
             super();
         }
         
         String getS() {
             return Outer.access$000(this$0);
         }
     }
     

4. accessing non-private fields, package: accessing.npriv

   class Outer {
       String s = "outer";
   
       class Inner {
           String getS() {
               return s;
           }
       }
   }
   

   is compiled to two classes:
   • Outer$Inner

     class Outer$Inner {
     
         final Outer this$0;
         
         Outer$Inner(Outer outer) {
             this$0 = outer;
             super();
         }
         
         String getS() {
             return this$0.s;
         }
     }
     

   • Outer.class

     class Outer {
     
         private String s = null;
         
         Outer() {
             s = "outer";
         }
     }
     

     • no static method this time