Doubt in inner classes

Question

public class Outer
           public static void main(String argv[])
                     Outer o=new Outer(); //1                    
                     Inner i =o.new Inner(); //2
                     //Inner i =new Inner();  //3
     i.showName();   
         public      class Inner{   
                void showName()
        System.out.println("hi");            
      }//End of Inner class
}I have few doubt regrd the above program..
1)when i create an inner class instance as in line 3,..Iam having an err like
non-static variable this cannot be referenced from a static context.. Bcas Inner is a non static member of class Outer it cant be referred without an instance of Outer as in line 2.. But my doubt is why it doesnt give such error (of static context issue) in the case of line 1...its a silly dbt but iam confused ...
2..Can we refer the inner class without outer class like in line 2., I have used
Inner without Outer ..is this ok... or shuld we use as
Outer.Inner i =o.new Inner(); //2
3)In the above line We r associating the instance of inner class with the instance of outer class and the type of inner class with the type of outer class (Outer.Inner )..wht does this mean..
can anyone pls help me understand this..
thnx.
mysha..

Answer 1

public class Outer
public static void main(String argv[])
Outer o=new Outer(); //1
er o=new Outer(); //1                    
Inner i =o.new Inner(); //2
//Inner i =new Inner();  //3
     i.showName();   
public      class Inner{   
void showName()
        System.out.println("hi");            
}//End of Inner class
}I have few doubt regrd the above program..
1)when i create an inner class instance as in line
3,..Iam having an err like
non-static variable this cannot be referenced from a
static context.. Bcas Inner is a non static member of
class Outer it cant be referred without an instance
of Outer as in line 2.. But my doubt is why it doesnt
give such error (of static context issue) in the case
of line 1...its a silly dbt but iam confused ...
Static methods of a class exist as soon as Java loads the class. Regular, or non-static, methods of a class belong to an object and only come into existence after you create an object of the class. Regular methods are called by an object. Static members are called using the class name.
Now, examine this simple program:
class Apple
     private String color;
     public Apple(String color)
          this.color = color;
     public void show()
          System.out.println("apple color: " + color);
     public static void greeting()
          System.out.println("Hello from the Apple class.");
public class  Demo
     public static void main(String[] args)
          Apple.greeting();  //1
          Apple a = new Apple("red");  //2
}After the Apple class loads, any static methods in the class exist. Since greeting() is a static method of the Apple class, it can be called in line 1 before any Apple objects exist. But, what about line 2? How can the Apple constructor with the String parameter, which is a method in the Apple class, be called? The constructor isn't declared as a static, so it shouldn't exist in that regard, and no objects of the class exist. So, when and how did the constructor come into existence. That seems to be the question you're struggling with. I think the answer is: a constructor sort of acts like a static method. In order to be able to call a constructor, the constructor must exist as soon as the class loads and before any objects exist. The result is, you can call a constructor at any time.
I think your example is similar to my example, but you only have one class:
public class Outer
public static void main(String argv[])
Outer o=new Outer(); //1
}After Java loads Outer, any static methods in Outer exist. Since main() is a static method, it exists. Subsequently, java calls the static main() method to begin execution of your program. In line 1, you call the default constructor for Outer. The default constructor isn't static, so it shouldn't exist, but just like the constructor in my example above, the default constructor acts like a static method, and therefore you can call it without getting an error.
Inner i =o.new Inner(); //2
2..Can we refer the inner class without outer class
like in line 2., I have used
Inner without Outer ..is this ok... or shuld we use
as
Outer.Inner i =o.new Inner(); //2
I'm not sure what the difference is. In both cases you end up with an object that was created with the expression:
o.new Inner()
you just have a different type for your object, i.e. Outer.Inner versus Inner.
3)In the above line We r associating the instance of
inner class with the instance of outer class and the
type of inner class with the type of outer class
(Outer.Inner )..wht does this mean..
can anyone pls help me understand this..
I think you said it: it means you have an Inner object that is "associated" with an Outer object. Like any other regular member in the Outer class, Inner can refer to any members of Outer. (A static member of Outer can't refer to regular members of Outer because static members exist before any objects exist, and when no objects exist, the regular members don't exist.) That means an Outer object must exist before you can create an Inner object.