aspose file tools*
The moose likes Programmer Certification (SCJP/OCPJP) and the fly likes Method local inner classes Big Moose Saloon
  Search | Java FAQ | Recent Topics | Flagged Topics | Hot Topics | Zero Replies
Register / Login
JavaRanch » Java Forums » Certification » Programmer Certification (SCJP/OCPJP)
Bookmark "Method local inner classes" Watch "Method local inner classes" New topic
Author

Method local inner classes

Harshaa Vardhan
Greenhorn

Joined: May 02, 2007
Posts: 2
This is with reference to the description of method local inner classes as explained as explained in the scjp book(K&B).How does marking the outer class's local variable as 'final' enable a method local inner class to access the variable ? When the method ends will the variable still be retained in the stack ?
megha joshi
Ranch Hand

Joined: Feb 20, 2007
Posts: 206
Hi,

I had the exact same question few months ago and here are the answers
http://www.coderanch.com/t/261699/java-programmer-SCJP/certification/Methd-local-class
Param Yalamanchili
Greenhorn

Joined: Apr 25, 2007
Posts: 8
Hi,
I think this is what you are talking about

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.


In that code, local variable to that particular method made final not the local variable to the outer class.

cheers
Chandra Bhatt
Ranch Hand

Joined: Feb 28, 2007
Posts: 1707
Good explanation Param,



cmbhatt
 
I agree. Here's the link: http://aspose.com/file-tools
 
subject: Method local inner classes