added content

Ram swaroop · Ram swaroop · commit 04ad549aa5ca · 2015-10-31T17:41:17.000+05:30
diff --git a/_posts/2015-08-20-nested-classes.md b/_posts/2015-08-20-nested-classes.md
@@ -245,7 +245,39 @@ inner class.
 Can             |Cannot
 ----------------|----------------
 Access private members of the outer/enclosing class. | Cannot use the local variables of the method the inner class is in.
-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. | You can't mark a method-local inner class public, private, protected, static, transient (just like a variable).
+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. | You can't mark a method-local inner class `public`, `private`, `protected`, `static` or `transient` (just like local variable declaration).
+
+#### Important Points
+
+* Method-local inner class __cannot access the local variables of the method inside which it is defined unless the 
+variables are marked `final`__. This is because the local variables of the method live on the stack and exist only 
+for the lifetime of the method. 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 is, the inner class object can't use them. Unless the local variables
+are marked final.
+
+{% highlight java linenos %}
+class MyOuter {
+    private String x = "Outer";
+
+    void doStuff() {
+        String z = "local variable";
+        
+        class MyInner {
+            public void seeOuter() {
+                System.out.println("Outer x is " + x);
+                System.out.println("Local var z is " + z); // won't compile, making 'z' final will solve the problem
+            } // close inner class method             
+        } // close inner class definition
+    } // close outer class method doStuff()
+} // close outer class
+{% endhighlight %}
+
+* 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.
    
                    
 
