Extending an inner class (6 lines of code)

// Mammal.java
public class Mammal {
public class Hand {
// Human.java
public class Human extends Mammal {
public class Hand extends Mammal.Hand { // (1)
}This gives me compilation error at (1).
If I change Human.java as below, the code works.
// Human.java
public class Human extends Mammal {
public class HumanHand extends Mammal.Hand {
}If I want my original class name "Human.Hand", what should I do?

the compiler certainly doesn't accept 2 public class with the same name.

Similar Messages

Cann't extend a inner class where as can Implement a nested Interface

i cann't extend a inner class in some other outer class . Where as i can implement the nested Interface in some other class. Why????
for example:-
class ABC
class Inner
/* class body */
interface TempInterface
/* interfacebody */
class OuterClass
class InnerTwo extends ABC.inner //(line 1)Will give error
class InnerTwo implements ABC.TempInterface //(line 2)Will run fine
the line 1 is going to give compilation error i.e not in the scope but the line 2 will run fine .
Both of the things are in the same class but giving 2 other results.
I am not getting sufficient reasons for it.
Can any one help me????
Reagrds
Arunabh

As far as the language is concerned, the classonly
exists in the context of an instance of theenclosing
class.This still exhibits a class/object confusion to me.
It should be 'instance only exists ...' or 'instance
can only exist'. The class only exists in the
scope of the enclosing class, but this is another
issue.I'm not following what you're saying. The second sentence sounds like you're disagreeing with me. The last sentence sounds like you're agreeing with me.
A non-static nested class is an instance member, just like an instance method or instance variable. As such, as far as the language is concerned, that class only exists in the context of an instance of the enlcosing class.It's not just instances of the nested class--its the class definition itself that only exists within the context of an instance of the enclosing class. That's why you have to do anEclosingIntstance.NestedClass and can't do EnclosingClass.NestedClass.

No of classes, Methods, Lines of codes, DLL's used and Third Party Libraries details identifying tools

We have started a project to migrate 100+ Web Applications developed using legacy Microsoft technologies to latest .Net 4.5 Framework.
The following are the planned migration approach
Classic Asp à
Asp.Net 1.1 Framework à Asp.Net 4.5 Framework
Asp.Net 2.0, 3.5, 4.0 Framework à         Asp.Net 4.5 Framework (Direct Migration)
Asp.Net 2.0, 3.5, 4.0 Framework à         Asp.Net 4.5 Framework (Application Rewrite
using MVC/Entity Framework)
VB 6 (COM/DCOM) à
C# .Net 4.5 (Web Services)
We have to analyze 100+ applications to categorize them as Simple/Medium/Complex conversions for planning the timeline for completing the migration activities.
Analysis includes identifying the following details - No of classes, Methods, Lines of codes, DLL’s used and Third Party Libraries details
for 100+ Microsoft applications.
Could you please let me know do we have any effective tool to identify above mentioned details?

This forum is for Microsoft Project Server, an EPM tool. You will need to find a more suitable forum for your question.
Good Luck with the conversion!
Rod Gill
Author of the one and only Project VBA Book
www.project-systems.co.nz

Extending a member inner class

I have a class
public class A{
class InnerClassB{
Now the question is how to extend the inner class would it be
class ExtendingInnerClassB extends A.B{
or else?
I am not sure anybody knows?

Regarding inheritance from inner classes you must define your constructor:
public ExtendedInnerClass(EnclosingClass EC) { EC.super(); }
why?????
well
1. Where is the handle? The handle is an internal thing which is designed to accept the enclosing class. It is something which is not in the programmer's control. when there is an inner class, it is natural that the inner class cannot exist without its outer class. And that is the reason why the instantiation of an inner class is done using new OuterClass().new Innerclass(). U can see that the innerClass object is created based on the outer class object (assuming that the inner Class is not static). I hope that this is clear. Now .. the whole point is how does the compiler know that the Outerclass is the enclosing class? When the above line is compiled, the tricky handle in the inner class is assigned to the Outer class. So any reference henceforth is made based on this handle.
2. In the Inherited Inner class, there is no way to assoicate the handle in the above manner. Hence we are forcing by calling the super().
3 Otherwise why not simply create with: new InheritedInnerClass(EnclosingClass)? This is not possible. What if the inherited inner class needs a constructor in the above manner. That is assume that there is a class A. Then if the Inner Class needs the constructor to be InnerClass(A a, EnclosingClass b) for some other purpose, then what judgement can the compiler take? So that answers the question <b>Can't the compiler compile the inherited inner class assuming a handle to the enclosing class and then force an instance to be created using the EnclosingClass.new syntax?</b> Becuase in this case it cant go by any assumption.
4. Maybe the compiler designers can make some change such that the inherited inner class should have all its constructors beginning with the enclosing object and there should be atleast one constructor. But somehow I feel that it is too much of asking.

Accessing Enclosing Class Members From Inner Class Subclass

I have the following scenario that I cannot get to work. Notice the comments in B.doWork() for the problem code. In B.doWork(), how do I access m_strA?
* A.java
* Created on July 5, 2002, 2:20 PM
package Projects.InnerTrouble.Files;
public class A {
     public abstract class InnerA {
          public abstract void doWork ();
     public String m_strA;
     /** Creates new A */
     public A ()
               new InnerA() {
                         public void doWork ()
                                   System.out.println("A$InnerA$1's doWork() called!");
                                   m_strA = "Annonymous subclass of InnerA's doWork did this";
                    }.doWork();
     * @param args the command line arguments
     public static void main (String args[])
               A oTemp = new A();
               System.out.println(oTemp.m_strA);
               B.getB(oTemp).doWork();
               System.out.println(oTemp.m_strA);
class B extends A.InnerA {
     public B (A a)
               a.super();
     public void doWork ()
               System.out.println("B's doWork() called!");
               // How do I access m_strA within B's doWork() method? The following is what I would expect to be the answer, but it does not compile
               // A.this.m_strA = "B's doWork did this";
     private static A.InnerA sm_oInnerA;
     public static A.InnerA getB (A a)
               if (sm_oInnerA == null)
                    sm_oInnerA = new B(a);
               return (sm_oInnerA);

The whole point is that B is not an inner class of A
so it does not have access to A's member variables.
Eventhough B extends an inner class of A, that does
not make B an inner class of A. That is in the JLS,
but not so elegantly as I have put it, hehe.
If B were an innerclass of InnerA, then it would
qualify to access A's member variables.OK, I think that you are finally getting through to my thick skull on this one. Let me restate and get your check-off on my understanding of the situation.
The only classes with access to A's this reference are A and inner classes of A that are found within the definition of A. So, despite the fact that A and B are in the same package (and B should have access to A's non-private members because B and A are in the same package), and despite the fact that we would normally state that B "is a" InnerA (which is an inner class of A and would have access to a reference to the A.this reference), B is not allowed access to A.this (because B "is not really a" InnerA in the same way that the anonymous implementation of InnerA "is a" InnerA). However, nothing would prevent me from giving B access to a reference of the enclosing A as long as it was done via a method of InnerA, and as long as the implementation of that method is contained in A's implementation.
Does this "access" rule realy make sense? Are you aware of the justification for this rule? Or is the justification stated in the JLS? I would think that the compiler ought to be able to figure this kind of thing out and allow it. It seems to me the fact that I defined B in the way that I did, and the fact that B "is a" InnerA, implies that I desired a fairly tight relationship to A. In fact, I desired the exact relationship that exists for the anonymous implementation of InnerA.
The following is a modified version of my original example that runs as I originally wanted it to, but works around the access rules discussed on this forum thread:
* A.java
* Created on July 5, 2002, 2:20 PM
package Projects.InnerTrouble.Files;
public class A {
     public abstract class InnerA {
          public abstract void doWork ();
          /** added to allow implementors of InnerA that are not enclosed in A's class definition to have access to the enclosing class */
          public A myEnclosingInstance ()
                    return (A.this);
     public String m_strA;
     /** Creates new A */
     public A ()
               new InnerA() {
                         public void doWork ()
                                   System.out.println("A$InnerA$1's doWork() called!");
                                   m_strA = "Annonymous subclass of InnerA's doWork did this";
                    }.doWork();
     * @param args the command line arguments
     public static void main (String args[])
               A oTemp = new A();
               System.out.println(oTemp.m_strA);
               B.getB(oTemp).doWork();
               System.out.println(oTemp.m_strA);
class B extends A.InnerA {
     public B (A a)
               a.super();
     public void doWork ()
               System.out.println("B's doWork() called!");
               // The following is what I would expect to be the answer, but it does not compile
               // A.this.m_strA = "B's doWork did this";
               // added myEnclosingInstance() to get functionality desired above
               myEnclosingInstance().m_strA = "B's doWork did this";
     private static A.InnerA sm_oInnerA;
     public static A.InnerA getB (A a)
               if (sm_oInnerA == null)
                    sm_oInnerA = new B(a);
               return (sm_oInnerA);
}

Extending a nested class and parent access

I want the child of the abstract inner class to have access to the inner classes parent's variables. I know that an inner class can access it's parent's variables and methods with the "[ParentClass].this.[var/method]" syntax. What's the appropriate syntax for the situation I'm describing?
My setup is like this:
class Canister {
int a = 0;
public abstract class Behavior
class Lonely Behavior extends Behavior
public int getParentVariable() {
return Canister.this.a;
}Thanks!
-stephen

The correction to my code is:
class Canister
int a = 0;
public abstract class Behavior
class LonelyBehavior extends Canister.Behavior
public int getParentVariable() {
return Canister.this.a;
}The compiler doesn't have a problem with me extending Canister.Behavior because it's public inside of Canister. But as I explained, the "[ParentClass].this.[var/method]" syntax doesn't work.
This is inconsistent with inheritance: you'd think that if you extend an inner class, you would inherit the abilities and characteristics of that inner class, just as you would in other cases of inheritance. It's also inconvenient: if the inner class is abstract because you want programmers to extend and upgrade it, those programmers have to change the source code of the enclosing class to include the new classes.
Anyway, thanks for the info.

Inner Classes doubts

Hi All,
I am trying to learn Inner classes in Java. I am referring to the book Core Java by Horstmann and Cornell.
I know that there are various types of inner classes namely:
- Nested Inner classes
- Local Inner classes
- Annonymous Inner classes
- static inner classes
First I am on with Nested Inner classes :
Following is the code which I am executing :
package com.example.innerclass;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Date;
import javax.swing.JOptionPane;
import javax.swing.Timer;
public class InnerClassTest {
      * @param args
     public static void main(String[] args) {
          // TODO Auto-generated method stub
          TalkingClock clock = new TalkingClock(1000,true);
          clock.start();
//          JOptionPane.showMessageDialog(null,"Quit Program");
//          System.exit(0);
class TalkingClock
     private int interval;
     private boolean beep;
     public TalkingClock(int interval, boolean beep){
          this.interval = interval;
          this.beep = beep;
     public void start(){
          ActionListener listener = new TimePrinter();
          Timer t = new Timer(interval,listener);
          t.start();
     private class TimePrinter implements ActionListener{
          public void actionPerformed(ActionEvent event){
               Date now = new Date();
               System.out.println("At the tone time is : "+now);
               if(beep)
                    Toolkit.getDefaultToolkit().beep();
}Following are my doubts :
1. Why do we need to give the line
JOptionPane.showMessageDialog(null,"Quit Program");
System.exit(0);without this line the program doesn't show any output.
2. I didn't understand this syntax.
You can write inner object constructor more explicitly using the syntax. :
outerObject.new InnerClass(construction parameters)
For e.g.
ActionListener listener = this.new TimePrinter();
Here the outer class reference of the newly constructed TimePrinter object is set to this reference of the method that creates the inner class object. the this. qualifier is redundant. However, it is also possible to set the outer class reference to another object by explicilty naming it. For e.g if TimePrinter were a public inner class, you could construct a TimePrinter for any talking clock.
TalkingClock jabberer = new TalkingClock(1000,true);
TalkingClock.TimePrinter listener = jabberer.new TimePrinter();
Please do help me understand this concept.
Thanks
Siddharth

I have understood that this explanation :
i) assuming that TimePrinter is an inner class of TalkingClock, that you'd need an instance of the later in order to create an instance of the former.Yes.
Being a non-static inner class, it can not be instantiated out of context ... which context is the outer class.No. See my reply 11. The "context" is an instance of the outer class - it bears repeating.
ii) jabberer is the outer instance that you are providing.Yes (more accurately it's a reference to an instance of the outer class, but that would be nit-picking).
The left side is identifying the class, the right side is identifying the instanceNo.
I'm not sure what you're calling left side and right side.
If you're talking about both sides of the equals sign, then no, it's completely wrong.
If you're talking about both sides of the "point" sign, then it's wrong too, just a bit less wrong.
Let's revise this step by step (good thought process).
1. in first line we are getting an outer class reference with this code
TalkingClock jabberer = new TalkingClock(1000,true);
this line is very natural and easily understood. Yes. The correct wording would be merely "we are getting a reference to an instance of the outer class". Sorry to insist densely.
2. Now when we come to the second line, i.e. where we try to instantiate an inner class with this line of code
TalkingClock.TimePrinter listener = jabberer.new TimePrinter();
- I do understand the concept that we need an instance of outer class in order to create an instance of inner class as inner class is visible only to outer class.No. We need an instance of the outer class as the inner class is non-static, and by definition needs an instance of the outer class. That has nothing to do with visibility (public vs private vs...). Again, some words have special meanings in the Java world.
- I also do understand that it cant be instantiated out of context. I see you like this expression, but it is too vague and misleads you. Please forget about it for a moment (no offense to otherwise helpful and knowledgeable abillconsl).
- I also do understand that left side is identifying the class and right side is identifying the instance. ANDAgain I'm afraid of which "sides" you're talking about.
- that in this line TalkingClock.TimePrinter listener = new TalkingClock().new TimePrinter();
the outer class is anonymous (new TalkingClock()) as we don't require its name here Poor choice of words again. Anonymous classes do exist in Java, but are a totally different concept, that is not related to this line.
- Also in this line TalkingClock.TimePrinter listener = jabberer.new TimePrinter();
I understood the left side part i.e. TalkingClock.TimePrinter listener =
We are attaching the outer class reference with the inner class that's absolutely understandable. Not at all!
This just declares a variable listener, whose type is TalkingClock.TimePrinter (or more accurately com.example.innerclass.TalkingClock.TimePrinter).
Then follows an assignment:
WHAT I don't understand is the right hand side, i.e., the statement jabberer.new TimePrinter();
1. I am unable to digest the fact that we can do something like anobject.new
new is an operator that is used to instantiate an instance of an object. I am unable to digest that we can do x.new?See my previous reply. This is short-hand syntax Sun chose to pass a reference to an instance of the outer class (here, jabberer) to the constructor of the inner class. They could have chosen something else. Again, bear with it.
I only know that we can do is new SomeClass(); AND NOT instance.new SomeClass();
Now you know better:
The second form is valid - only if SomeClass is a non-static inner class defined in a class of which instance is an instance.
2. Is there something to this conceptually OR this is only a syntax and that I should learn it.
I want to understand and grasp if there is some concept behind it rather than just learn and mug up. See my previous reply. Each instance of a non-static inner class stores a reference to an instance of the outer class. There must be a way (a syntax) to specify which instance (of the outer class) should be stored in the instance (of the inner class).
This particular syntax is just a syntax, the "concept" is that the instance of the inner class stores a (unmodifiable) reference to the instance of the outer class that was specified when the instance of the inner class was created.
I don't know if that deserves to be called a concept, but that's an interesting thing to keep in mind (there are some not-so-obvious implications in terms of, e.g. garbage collection).
Best regards.
J.

Calling functions of the inner class in .java code file

Hello,
I created a .java code file in Visual J#.Net and converted it into
the application by adding the "public static void main(String args[])"
function.
I have created the two classes one extends from Applet, and the other
extends from Frame. The class which I inherited from the Frame class becomes
the inner class of the class extended from the Applet. Now How do I
call the functions of the class extended from Frame class - MenuBarFrame
class. the outline code is
public class menu_show extends Applet
------init , paint action function---------
public class MenuBarFrame extends Frame
paint,action function for Menu
public static void main(String args[])
applet class instance is created
instance of frame is created
Menu , MenuBar, MenuItem instance is created
and all these objects added
I have Created MenuBarFrame class instance as
Object x= new menu_show().new MenuBarFrame
????? How to call the functions such as action of MenuBarFrame class - what
should be its parameters??????
}

Here's how I would do it:
interface Operation {
    public int op(int y);
class X {
    private int x;
    public X(int x) {
        this.x = x;
    private class Y implements Operation {
        public int op(int y) {
            return x+y;
    public Operation createOperation() {
        return new Y();
    public static void main(String[] args) {
        X app = new X(17);
        Operation f = app.createOperation();
        System.out.println(f.op(-11));
}Your code, however, has some serious "issues". You typically don't
instantiate an applet class -- that's the job of the applet viewer or Java plugin
your browser is using. If you instantiate the applet directly, you're going
to have to supply it an AppletStub. Do you really want to go that way?
Again, use an applet viewer or browser, or better yet, why write applets at all?

Inner Class extending the outer class

Could anyone explain this code to me? It can compile and run. Could anyone tell me what the class Main.Inner.Inner is? What members does it consists of? How the compiler manage to build such a class?
public class Main {
    public static class Inner extends Main {
    public static void main(String[] args) {
        System.out.println("Hello, world.");
}

By the way, it's not really an inner class, because it's static. It's just a nested class.
You might want to have a nested class extend its enclosing class if, maybe, you wanted to delegate to subclasses and didn't want to create a lot of extra source code files, which might make sense if the nested subclasses were really small.
public abstract class Animal {
public abstract void makeSound();
private Animal() {} // can't be directly instantiated
private static class Dog extends Animal {
    public void makeSound() { System.out.println("woof"); }
private static class Cat extends Animal {
    public void makeSound() { System.out.println("meow"); }
private static class Zebra extends Animal {
    public void makeSound() { System.out.println("i am a zebra"); }
public static Animal get(String desc) {
    if ("fetches sticks".equals(desc)) {
      return new Dog();
    if ("hunts mice".equals(desc)) {
      return new Cat();
    if ("stripey horse".equals(desc)) {
      return new Zebra();
    return null;
public class AnimalTest {
public static void main(String... argv) {
    Animal a = Animal.get("fetches sticks");
    a.makeSound();
}

Total number of lines of code in a class.

Dear Experts,
Given a class, I want to find out the total number of lines of code in all of its methods. Following sub-parts are derived.
1. Find out all the methods of the class
2. Find out the number of lines for each of these methods and finally add the total number.
Can you kindly let me know how I can do this? Thanks a lot !
Best Regards, Vikram

Be aware that a 2D array is an array of arrays, which don't necessarily have to be the same length. e.g.int[][] a = new int[2][];
a[0] = new int[10];
a[1] = new int[20];
/* a.length == 2
a[0].length == 10
a[1].length == 20*/

Is it too much lines of code inside a class file?

Hi,
I was wondering about how many lines can be considered too much in a java class file. I saw some class files with more the two thousand lines of code and even more than three thousand lines. When we have so many lines in the code I've realized that the file becomes slow for edition and it's not readable as it should be. So, as a best practice, or even due to technical issues, in average how many lines of code we'd write in order to keep the readability and avoid compile and build issues? How many lines a class should have without putting our code and performance at risk ?
thanks a lot

My general rule of thumb--in a class everything shold be very consistent, that is to say: you should be focusing on 1 idea in your class. IMO: If you have a class for users, you need to consistent in just what that class does. When the class becomes large, then look for related themes that run through methods of that class, and if here are many, you should make a "related class" that does satelite functions of the "core" offered in the main user class.
Thousands of lines do not a good class make, I break in to related categories of classes long before then, and as a rule I keep under 500 lines in a class--usually under 300. In any case, no more lines of code need go into a class than that to implement the core features in the main idea for that class--and no less lines of code than is needed too, don't religate a method to another class just becasue you feel it would make the class it belongs too big.
Along the idea of the user class:
Storage for the user data
Home information
Work information
physical information
tastes and preferences
family
and etc
all of these could be a class in and of themselves, but definetely are closely related to the user class.

How to override a method in an inner class of the super class

I have a rather horribly written class, which I need to adapt. I could simply do this if I could override a method in one of it's inner classes. My plan then was to extend the original class, and override the method in question. But here I am struggling.
The code below is representative of my situation.
public class ClassA
   ValueChecks vc = null;
   /** Creates a new instance of Main */
   public ClassA()
      System.out.println("ClassA Constructor");
      vc = new ValueChecks();
      vc.checkMaximum();
     // I want this to call the overridden method, but it does not, it seems to call
     // the method in this class. probably because vc belongs to this class
      this.vc.checkMinimum();
      this.myMethod();
   protected void myMethod()
      System.out.println("myMethod(SUPER)");
   protected class ValueChecks
      protected boolean checkMinimum()
         System.out.println("ValueChecks.checkMinimum (SUPER)");
         return true;
      protected boolean checkMaximum()
         return false;
}I have extended ClassA, call it ClassASub, and it is this Class which I instantiate. The constructor in ClassASub obviously calls the constructor in ClassA. I want to override the checkMinimum() method in ValueChecks, but the above code always calls the method in ClassA. The ClassASub code looks like this
public class ClassASub extends ClassA
   public ClassAInner cias;
   /** Creates a new instance of Main */
   public ClassASub()
      System.out.println("ClassASub Constructor");
   protected void myMethod()
      System.out.println("myMethod(SUB)");
   protected class ValueChecks extends ClassA.ValueChecks
      protected boolean checkMinimum()
         System.out.println("ValueChecks.checkMinimum (SUB)");
         return true;
}The method myMethod seems to be suitably overridden, but I cannot override the checkMinimum() method.
I think this is a stupid problem to do with how the ValueChecks class is instantiated. I think I need to create an instance of ValueChecks in ClassASub, and pass a reference to it into ClassA. But this will upset the way ClassA works. Could somebody enlighten me please.

vc = new ValueChecks();vc is a ValueChecks object. No matter whether you subclass ValueChecks or not, vc is always of this type, per this line of code.
// I want this to call the overridden method, but it does not, it seems to > call
// the method in this class. probably because vc belongs to this class
this.vc.checkMinimum();No, it's because again vc references a ValueChecks object, because it was created as such.
And when I say ValueChecks, I mean the original class, not the one you tried to create by the same name, attempting to override the original.

Inner Class Question

My question pertains to the code at the bottom of this post.
I don't understand why the compiler doesn't give an error for the line below. Why would it let you refer to something inside the class (in this case I'm referring to ClassWithInnerClass.MyInnerClass) unless it were static?
ClassWithInnerClass.MyInnerClass mic = cwic.retMyInnerClass();To illustrate why I'm asking, I created 2 ints ("regularInt" and "staticInt") inside class "ClassWithInnerClass". The compiler let me set the value of "staticInt" from within main whereas it wouldn't let me do so w/ "regularInt" (which is why I commented that line out). Don't get me wrong though - I understand the reasons why the compiler behaves as it does for "regularInt" and "staticInt". I understand that a static variable can be accessed without instantiating a class (and that there's only 1 created no matter how many classes are instantiated). I also understand that, to access a non-static variable, you need to instantiate a class. My question arises only because of trying to extend that logic to MyInnerClass.
I can already take a guess that the answer is going to be something like, "the reason it works this way is because class 'MyInnerClass' is just a declaration NOT a definiton". I guess I just want confirmation of this and, if possible, some reasoning behind this logic.
HERE'S THE CODE...
class CreateInnerClasses {
     public static void main (String args[]) {
          ClassWithInnerClass cwic = new ClassWithInnerClass();
          ClassWithInnerClass.MyInnerClass mic = cwic.retMyInnerClass();
          //ClassWithInnerClass.regularInt = 5;
          ClassWithInnerClass.staticInt = 10;
          mic.printIt();
class ClassWithInnerClass {
     public int regularInt ;
     static public int staticInt;
     class MyInnerClass {
          void printIt() {
               System.out.println("Inside ClassWithInnerClass.myInnerClass");
     MyInnerClass retMyInnerClass () {
          return new MyInnerClass();

The line    ClassWithInnerClass.MyInnerClass mic = cwic.retMyInnerClass();is accepted because the name of the inner class is ClassWithInnerClass.MyInnerClass. This has nothing to do with accessing fields even though the syntax is similar.
On the other hand, the line    SomeClassWithAnInnerClass.InnerClass ic = new SomeClassWithAnInnerClass.InnerClass();is not accepted because the nested class SomeClassWithAnInnerClass.InnerClass is not static: you must have an instance of the outer class available. The correct syntax for calling the constructor of the inner class would be    Outer.Inner instance = outerInstance.new Inner();In this case you could write:    ClassWithInnerClass.MyInnerClass mic = new SomeClassWithAnInnerClass() . new InnerClass();
    // OR:
    ClassWithInnerClass.MyInnerClass mic = cwic . new InnerClass();The Java tutorial has a pretty good explanation on nested classes:
http://java.sun.com/docs/books/tutorial/java/javaOO/nested.html
http://java.sun.com/docs/books/tutorial/java/javaOO/innerclasses.html

BUG: Oracle Java Compiler bug with anonymous inner classes in constructor

The following code compiles and runs just fine using 1.4.2_07, 1.5.0_07 and 1.6.0_beta2 when compiling and running from the command-line.
It does not run when compiling from JDeveloper 10.1.3.36.73 (which uses the ojc.jar).
When compiled from JDeveloper, the JRE (both the embedded one or the external 1.5.0_07 one) reports the following error:
java.lang.VerifyError: (class: com/ids/arithmeticexpr/Scanner, method: <init> signature: (Ljava/io/Reader;)V) Expecting to find object/array on
stack
Here's the code:
/** lexical analyzer for arithmetic expressions.
Fixes the lookahead problem for TT_EOL.
public class Scanner extends StreamTokenizer
/** kludge: pushes an anonymous Reader which inserts
a space after each newline.
public Scanner( Reader r )
super( new FilterReader( new BufferedReader( r ) )
protected boolean addSpace; // kludge to add space after \n
public int read() throws IOException
int ch = addSpace ? ' ' : in.read();
addSpace = ch == '\n';
return ch;
public static void main( String[] args )
Scanner scanner = new Scanner( new StringReader("1+2") ); // !!!
Removing the (implicit) reference to 'this' in the call to super() by passing an instance of a static inner class 'Kludge' instead of the anonymous subclass of FilterReader fixes the error. The code will then run even when compiled with ojc. There seems to be a bug in ojc concerning references to the partially constructed object (a bug which which is not present in the reference compilers.)
-- Sebastian

Thanks Sebastian, I filed a bug for OJC, and I'll look at the Javac bug. Either way, OJC should either give an error or create correct code.
Keimpe Bronkhorst
JDev Team

Inner classes can't access parent classes in constructor

I'm having a problem where I have class A, which has an Inner class B, which has it's own inner class C. In C's constructor (the inner most class), i'm trying to access a method of A (the top most class), and I get a NullPointerException with trace:
at mearns.finance.DefaultPortfolio.access$0(DefaultPortfolio.java:1)
at mearns.finance.DefaultPortfolio$AccountsEditor$AccountsTableModel.<init>(DefaultPortfolio.java:253)
In this case "DefaultPortfolio" is class A, AccountsEditor is class B, and AccountsTableModel is class C. The line given in the second stack trace element is the line in C's constructor which calls Class A's method.
Debugging, I stop inside C's constructor. Before anything happens, debugger says this$1 is null. Then I step, and it calls super(), and now this$1 is an instance of class B (AccountEditor), but it's own this$1 (which should be an instance of class A) is still null.
I'm calling C's constructor from within B's constructor (but not A's), not sure if that makes a difference.
Can anyone explain what's going on here, and (hopefully) how I can work around it?
Thanks for any help.
When i debug

hm, I really don't know what is happening but I want to tell you about something that is not nice in your code and possibly it could cause the error.
Code behaves somwhat strange when you pass this out of a constructor. You do this implicitly when you create an inner classe which implicitly gets a reference to the outer class. Also just simple method calls can cause such effects.
This is because the construction process it not finished but methods are already called.
Even worse: the sub classes constructor possibly did not even start. Special to java is the fact that a method call can lead to an overridden method of a sub class who's constructors has not even passed the super() command.
My guess now is that you have that some kind of this situation in your code. You create an inner class in a constructor. That inner class calls back a method on the outer class. Now say that the method you are calling is defined in a sub class who's constructor still stucks in super() call. There we are.
I found a thread in a news group that covers exactly this problem:
It is therefore a good idea only to call private methods from constructors (that should then also call only private methods). Also if inner classes are created in the constructor then they should not call any non trivial / non private methods of the outer class. Calling overridden methods out of constructors should be avoided strictly!
Perhaps this has nothing to do with your problem. I cannot tell for sure.
But this sounds quite interesting.
Please tell me if my guess was right and if not post simple code the illustrated your problem.
Here a simple example also throwing NullPointerException:
class Outer {
int i = 42;
abstract class InnerSuper {
    InnerSuper() {
      foo();
    abstract void foo();
class InnerSub extends InnerSuper {
    void foo() {
      System.out.println(i);
public void bar() {
    new InnerSub();
public static void main(String[] args) {
    Outer o = new Outer();
    o.bar();
} It causes a NullPointerException because the InnerSub constructor did not run. I copied the example from a news group thread i found.
http://groups.google.de/group/comp.lang.java.programmer/browse_thread/thread/897fba792d689b29/a1ba2ed708636a30?q=inner+class+outer+this+reference+NullPointerException&rnum=4&hl=de#a1ba2ed708636a30
Here is a even simpler example of strange behavior - even without NullPointerExceptions.
class A {
     A() {
          System.out.println(getName());
     String getName() {
          return "A";
class B extends A {
     String NAME = "B";
     String getName() {
          return NAME;
new B();It will output null instead of B.
regards
Sven

Extending an inner class (6 lines of code)

Similar Messages

Maybe you are looking for