Win a copy of Node.js Design Patterns: Design and implement production-grade Node.js applications using proven patterns and techniques this week in the Server-Side JavaScript and NodeJS forum!

Vamsi Yalamanchili

+ Follow
since Apr 25, 2007
Cows and Likes
Total received
In last 30 days
Total given
Total received
Received in last 30 days
Total given
Given in last 30 days
Forums and Threads
Scavenger Hunt
expand Ranch Hand Scavenger Hunt
expand Greenhorn Scavenger Hunt

Recent posts by Vamsi Yalamanchili

Congratulations, what is the score you got?
14 years ago
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: 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.


1 Its not mentioned in the SCJP objectives, here is the link for itSCJP Objectives

2 According to above objectives, we only need to prepare these classes. DataInputStream, DataOutputStream, FileInputStream, FileOutputStream, ObjectInputStream, ObjectOutputStream and Serializable.

[ May 03, 2007: Message edited by: Param Yalamanchili ]
This code wont generate any warnings

public class Wonder
public static void main(String[] args)
List l = new ArrayList(); // no warning
List<String> ls = new ArrayList<String>(); //NO warning
[ April 30, 2007: Message edited by: Param Yalamanchili ]