Certification Objective Method-Local Inner Classes

Certification Objective —Method-Local Inner Classes

A regular inner class is scoped inside another class's curly braces, but outside any method code (in other words, at the same level that an instance variable is declared). But you can also define an inner class within a method:

 class MyOuter2 {      private String x = "Outer2";      void doStuff() {         class MyInner {            public void seeOuter() {              System.out.println("Outer x is " + x);            } // close inner class method         } // close inner class definition       } // close outer class method doStuff() } // close outer class 

The preceding code declares a class, MyOuter2, with one method, doStuff(). But inside doStuff(), another class, MyInner, is declared, and it has a method of its own, seeOuter(). The code above is completely useless, however, because it never instantiates the inner class! Just because you declared the class doesn't mean you created an instance of it. So if you want to actually use the inner class (say, to invoke its methods), then you must make an instance of it somewhere within the method but below the inner class definition. The following legal code shows how to instantiate and use a method-local inner class:

 class MyOuter2 {      private String x = "Outer2";      void doStuff() {         class MyInner {            public void seeOuter() {              System.out.println("Outer x is " + x);            } // close inner class method         } // close inner class definition         MyInner mi = new MyInner();  // This line must come                                      // after the class         mi.seeOuter();       } // close outer class method doStuff() } // close outer class 

What a Method-Local Inner Object Can and Can't Do

A method-local inner class can be instantiated only within the method where the inner class is defined. In other words, no other code running in any other method—inside or outside the outer class—can ever instantiate the method-local inner class. Like regular inner class objects, the method-local inner class object shares a special relationship with the enclosing (outer) class object, and can access its private (or any other) members. However, the inner class object cannot use the local variables of the method the inner class is in. Why not?

Think about it. The local variables of the method live on the stack, and exist only for the lifetime of the method. You already know that the scope of a local variable is limited to the method the variable is declared in. When the method ends, the stack frame is blown away and the variable is history. But even after the method completes, the inner class object created within it might still be alive on the heap if, for example, a reference to it was passed into some other code and then stored in an instance variable. Because the local variables aren't guaranteed to be alive as long as the method-local inner class object, the inner class object can't use them. Unless the local variables are marked final! The following code attempts to access a local variable from within a method-local inner class.

 class MyOuter2 {    private String x = "Outer2";    void doStuff() {      String z = "local variable";      class MyInner {        public void seeOuter() {          System.out.println("Outer x is " + x);          System.out.println("Local variable z is " + z);  //Won't Compile!        } // close inner class method      }   // close inner class definition    }     // close outer class method doStuff() }        // close outer class 

Compiling the preceding code really upsets the compiler:

 MyOuter2.java:8: local variable z is accessed from within inner class; needs to be declared final            System.out.println("Local  variable z is " + z);                                                         ^ 

Marking the local variable z as final fixes the problem:

 final String z = "local variable";  // Now inner object can use it 

And just a reminder about modifiers within a method: the same rules apply to method-local inner classes as to local variable declarations. You can't, for example, mark a method-local inner class public, private, protected, static, transient, and the like. The only modifiers you can apply to a method-local inner class are abstract and final, but as always, never both at the same time.

Exam Watch

Remember that a local class declared in a static method has access to only static members of the enclosing class, since there is no associated instance of the enclosing class. If you're in a static method there is no this, so an inner class in a static method is subject to the same restrictions as the static method. In other words, no access to instance variables.