Wrong field type for "this" in an inner class in JDK6?

I'm running into a strange result here and am not sure if it is a bug in Java or it is expected behaviour. I have an inner class on which I've used reflection to get the declared fields (class.getDeclaredFields()). However, when I loop over the list of fields and check the individual types, the "this" field returns the outerclass and not the inner class.

Is this expected behaviour? It seems quite odd to me.

Ex:

import java.lang.reflect.Field;

public class OuterClass {

    public class InnerClass{
        public String innerClassString;
            public InnerClass innerClass;

    }


    public static void main(String[] args) {

        // print the fields of the inner class
        for( Field field : OuterClass.InnerClass.class.getDeclaredFields())
            System.out.println( field.getName() + "   :::   " + field.getType());
    }
}

Output:

innerClassString   :::   class java.lang.String
innerClass   :::   class OuterClass$InnerClass
this$0   :::   class OuterClass

I expected this$0 to be of type OuterClass.InnerClass.

Is this a Java bug?开发者_高级运维 Is there anyway to workaround this unexpected behaviour?

Thanks,

Eric

Every non-static inner class maintains an invisible ivar that holds a reference to the outer class that it was instantiated for. That's what this$0 is.

Change InnerClass to public static class and see the difference.

For clarity, Oracle recommends this terminology:

http://download.oracle.com/javase/tutorial/java/javaOO/nested.html

Terminology: Nested classes are divided into two categories: static and non-static. Nested classes that are declared static are simply called static nested classes. Non-static nested classes are called inner classes.

...

An instance of InnerClass can exist only within an instance of OuterClass and has direct access to the methods and fields of its enclosing instance. ...

To instantiate an inner class, you must first instantiate the outer class. Then, create the inner object within the outer object with this syntax:

OuterClass.InnerClass innerObject = outerObject.new InnerClass();

===

Is there any access to the this$0 variable then from within the inner class if you want?

In a method of the inner class, you can say:

OuterClass outer = OuterClass.this;

or

System.out.println(OuterClass.this.toString());

This special variant of this - OuterClass.this - is accessing the this$0 ivar - it will return the OuterClass instance. Note that this is different than using the regular this inside an InnerClass method, which will return the current InnerClass instance.

===

Furthermore, how can I determine if I am processing the "this$0" field without using a string compare?

I'm unclear what you are trying to do, so I can't recommend how to achieve what you want.

this$0 is reference in Inner class which tells which instance of Outer class was used to create current instance of Inner class.
The more detail can see this question.

What does it mean if a variable has the name "this$0" in IntelliJ IDEA while debugging Java?