Why is an anonymous inner class containing nothing generated from this code?

by

I’m using polygenelubricants’s smaller snippet.

Remember there’s no concept of nested classes in the bytecode; the bytecode is, however, aware of access modifiers. The problem the compiler is trying to circumvent here is that
the method instantiate() needs to create a new instance of PrivateInnerClass. However, OuterClass does not have access to PrivateInnerClass‘s constructor (OuterClass$PrivateInnerClass will be generated as a package-protected class without a public constructor).

So what can the compiler do? The obvious solution is to change PrivateInnerClass to have a package-protected constructor. The problem here is that this will allow any other code which interfaces with the class to create a new instance of PrivateInnerClass, even though it’s explicitly declared as private!

To try and prevent that, the javac compiler is doing a little trick: instead of making PrivateInnerClass‘s regular constructor visible from other classes, it leaves it as hidden (actually it does not define it at all, but that’s the same thing from outside). Instead, it creates a new constructor which receives an additional parameter of the special type OuterClass$1.

Now, if you look at instantiate(), it calls that new constructor. It actually sends null as the 2nd parameter (of the type OuterClass$1) – that parameter is only used for specifying that this constructor is the one that should be called.

So, why create a new type for the 2nd parameter? Why not use, say, Object? It’s only used to differentiate it from the regular constructor and null is passed anyway! And the answer is that as OuterClass$1 is private to OuterClass, a legal compiler will never allow the user to invoke the special OuterClass$PrivateInnerClass constructor, as one of the required parameter types, OuterClass$1, is hidden.

I’m guessing JDT’s compiler uses another technique to solve the same problem.

More Related Contents:

  1. Can we create an instance of an interface in Java? [duplicate]
  2. Java inner class and static nested class
  3. What causes error “No enclosing instance of type Foo is accessible” and how do I fix it?
  4. Why does Java prohibit static fields in inner classes?
  5. Java8 Lambdas vs Anonymous classes
  6. Java: Static vs inner class [duplicate]
  7. Getting hold of the outer class object from the inner class object
  8. How can I include raw JSON in an object using Jackson?
  9. How to instantiate non static inner class within a static method?
  10. Instantiating inner class
  11. Java 8 Lambda Expressions – what about multiple methods in nested class
  12. What is the $1 in class file names?
  13. Can we create an object of an interface?
  14. Inner class within Interface
  15. How to pass parameters to anonymous class?
  16. Multiple inheritance for an anonymous class
  17. How can “this” of the outer class be accessed from an inner class?
  18. Is not an enclosing class Java
  19. Why do inner classes make private methods accessible?
  20. Can I access new methods in anonymous inner class with some syntax?
  21. non-static class cannot be referenced from a static context [duplicate]
  22. Inner class and local variables
  23. Setting outer variable from anonymous inner class
  24. Access “this” from Java anonymous class
  25. What does a variable being “effectively final” mean? [duplicate]
  26. Test cases in inner classes with JUnit
  27. Anonymous vs named inner classes? – best practices?
  28. In Java nested classes, can the enclosing class access private members of inner classes?
  29. Java: calling outer class method in anonymous inner class
  30. “Variable example might not have been initialized” in anonymous class

Leave a Comment