TestInnerEtc.java

import java.io.*;

public class TestInnerEtc {
   public static void main (String[] args)throws IOException{
      
      // Nested class can be accessed just like top-level 
      // classes. Only need Outer.Nested to qualify it.
      Outer.Nested n = new Outer.Nested();
      Outer.Nested.NestedNested nn = new Outer.Nested.NestedNested();
      Outer.Nested.NestedInner  ni = new Outer.Nested().new NestedInner();
      
      
      // Inner class needs an instance of Outer class to
      // construct it.
      Outer.Inner  i = new Outer().new Inner();
      Outer.Inner.InnerInner  ii = new Outer().new Inner().new InnerInner();
      Outer.InnerI oi = i;
      
      // Local class cannot accessed from anywhere 
      // out of its own scope.
      // However, we are using the Local indirectly here.
      
      Outer o = new Outer();
      o.aMethod(3, 4);  // just guess what will be displayed  
      Outer.bMethod(3, 4);  // just guess what will be displayed  
      
      System.in.read();
   }
}

class Outer {
   public  int a  = 1;
   private int b  = 2;
   static  int sa = 1;
   static  int sb = 2;  
   
   public void aMethod(final int c, int d) {
      final  int e = 5;
             int f = 6;  
            
      // No public/protected/private modifier allowed
      // for Local classes
      class Local {
         int aLocalMtd(int g) {
            // Local class cannot access non-final 
            // local (automatic) variables or parameters
            return (a + b + + sa + sb + c + e + g);//No d,f allowed
         }
      }
      
      Local l = new Local();
      int x = l.aLocalMtd(7);  
      System.out.println(x);            
   }
   
   public static void bMethod(final int c, int d) {
      final int e = 5;
            int f = 6;  
            
      // No public/protected/private modifier allowed
      // for Local classes
      class LocalInStatic {
         int bLocalMtd(int g) {
            // LocalInStatic class cannot access non-final 
            // local (automatic) variables or parameters
            // LocalInStatic class cannot access non-static 
            // Enclosing class instance variables
            return (sa + sb + c + e + g);//No a, b, d,f allowed
         }
      }
      
      LocalInStatic l = new LocalInStatic();
      int x = l.bLocalMtd(7);  
      System.out.println(x);            
   }
   
   // any access modifier is allowed for Inner/Nested classes
   protected static class Nested {
      // You can difine anything in a Nested Top-level class
      static int s = 3;
             int i = 3;
      static int f() {return 1;}
             int g() {return 2;}
      static class NestedNested {
         NestedNested() {System.out.println("NestedNested");}
      }
      class NestedInner {
         NestedInner() {System.out.println("NestedInner");}
      }
   }
   	
   class Inner implements InnerI {
      // You cannot difine anything static in an Inner class
      class InnerInner {
         InnerInner() {System.out.println("InnerInner");}
      }
   }
   
   // all nested interface are implicitly static
   interface InnerI {
      interface InnerInnerI {
      }
   }
   
   interface InnerII {
   }
   
   // notice class cannot extends more than one super classes
   // interface can extends more than one interfaces
   static interface InnerIII extends InnerI, InnerII {
   }
}

// Not allowed
//static interface OutI {
//}