The only practical difference between the anonymous classes and the top-level classes is that the anonymous classes will hold an implicit reference to the outer class. This won’t manifest itself in performance, but will impact you if you ever serialise these classes.
As of JDK 18, no. JDK 18 omits enclosing instance fields from inner classes that don’t use it. However, prior to JDK 18, yes, instances of anonymous inner classes hold on to a reference to their enclosing instances even if these references are never actually used. For example, this code: public class Outer { public … Read more
In the Analyze menu, select “Run Inspection by Name…”. In the search box, type “Anonymous” and select the one that says “Anonymous class may be replaced by lambda” or something to that effect. Select your scope and start the analysis. In the results, you can inspect them individually and click the “Replace with lambda” link … Read more
java.lang.Object has no a methods declared (2), while the anonymous class returned by the class instance creation expression new Object() { public void a() {} } does (1). Use Java 10’s local variable type inference (var) to make the second option as valid as the first one. var object = new Object() { public void … Read more
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 … Read more
What you are seeing here is an anonymous inner class: Given the following interface: interface Inter { public String getString(); } You can create something like an instance of it like so: Inter instance = new Inter() { @Override public String getString() { return “HI”; } }; Now, you have an instance of the interface … Read more
There is almost no difference. In fact the there is an old saying about closures and objects. Closures are the poor man’s object, and objects are the poor man’s closure. Both are equally powerful in terms of what they can do. We are only arguing over expressiveness. In Java we are modeling closures with Anonymous … Read more
Except for the already mentioned issues regarding good programming style and inheritance misuse, there is one more subtle problem – inner classes and (non-static) anonymous class instances act as closures. This means that they keep an implicit reference to the enclosing class instance. This can result in preventing of garbage collection and in the end, … Read more
I tend to use anonymous inner classes in situations where I don’t need to have a full-blown class just to perform some task. For example, if I want to implement an ActionListener or Runnable, but I don’t think having an inner class would be necessary. For example, for starting a simple Thread, using an anonymous … Read more