Java inner class .class file names

Question

If I have an inner class, like this:

public class Test
{
    public class Inner
    {
     // code ...
    }

    public static void main(String[] args)
    {
     // code ...
    }
}

When I compile it, I expect it should generate two files:

Test.class
Test$Inner.class

So why do I sometimes see classfiles like SomeClass$1.class, even though SomeClass does not contain an inner class called "1"?

Answer 1

The SomeClass$1.class represent anonymous inner class

hava a look at the anonymous inner class section here

Answer 2

to build up on hhafez : SomeClass$1.class represents anonymous inner classes. An example of such a class would be

public class Foo{
  public void printMe(){
    System.out.println("redefine me!");
  }
}


public class Bar {
    public void printMe() {
    Foo f = new Foo() {
        public void printMe() {
     System.out.println("defined");
        }
    };
    f.printMe();
    }
}

From a normal Main, if you called new Bar().printMe it would print "defined" and in the compilation directory you will find Bar1.class

this section in the above code :

    Foo f = new Foo() {
        public void printMe() {
     System.out.println("defined");
        }
    };

is called an anonymous inner class.

Answer 3

Hey ur question is rite i also got same one here is real solution

When ur inner class is private den JVM req its constructor to make its copy den there is some problem 2 understand which u need to learn inner logic of compiler n JVM just remember dat compiler itself makes an anonymous class for accessing the constructor by making one more

file the compiler enables JVM to run dat class without access specifier problems

Answer 4

I know I'm late, but I came across this question when trying to determine some inner class behavior myself and thought this discovery might help someone else.

You'll also get something like SomeClass$1.class if your class contains a private inner class (not anonymous) but you instantiate it at some point in the parent class.

For example:

public class Person {

    private class Brain{
        void ponderLife() {
            System.out.println("The meaning of life is...");
        }
    }

    Person() {
        Brain b = new Brain();
        b.ponderLife();
    }
}

This would yield:

Person.class
Person$Brain.class
Person$1.class

Personally I think that's a bit easier to read than a typical anonymous class especially when implementing a simple interface or an abstract class that only serves to be passed into another local object.