Is it possible to make anonymous inner classes in Java static?

JavaSyntaxInner Classes

Java Problem Overview

In Java, nested classes can be either static or not. If they are static, they do not contain a reference to the pointer of the containing instance (they are also not called inner classes anymore, they are called nested classes).

Forgetting to make an nested class static when it does not need that reference can lead to problems with garbage collection or escape analysis.

Is it possible to make an anonymous inner class static as well? Or does the compiler figure this out automatically (which it could, because there cannot be any subclasses)?

For example, if I make an anonymous comparator, I almost never need the reference to the outside:

  Collections.sort(list, new Comparator<String>(){
       int compare(String a, String b){
          return a.toUpperCase().compareTo(b.toUpperCase());

Java Solutions

Solution 1 - Java

No, you can't, and no, the compiler can't figure it out. This is why FindBugs always suggests changing anonymous inner classes to named static nested classes if they don't use their implicit this reference.

Edit: Tom Hawtin - tackline says that if the anonymous class is created in a static context (e.g. in the main method), the anonymous class is in fact static. But the JLS disagrees: >An anonymous class is never abstract (§ An anonymous class is always an inner class (§8.1.3); it is never static (§8.1.1, §8.5.1). An anonymous class is always implicitly final (§

Roedy Green's Java Glossary says that the fact that anonymous classes are allowed in a static context is implementation-dependent: >If you want to baffle those maintaining your code, wags have discovered javac.exe will permit anonymous classes inside static init code and static methods, even though the language spec says than anonymous classes are never static. These anonymous classes, of course, have no access to the instance fields of the object. I don’t recommend doing this. The feature could be pulled at any time.

Edit 2: The JLS actually covers static contexts more explicitly in §15.9.2: >Let C be the class being instantiated, and let i be the instance being created. If C is an inner class then i may have an immediately enclosing instance. The immediately enclosing instance of i (§8.1.3) is determined as follows.

>- If C is an anonymous class, then: > - If the class instance creation expression occurs in a static context (§8.1.3), then i has no immediately enclosing instance. > - Otherwise, the immediately enclosing instance of i is this.

So an anonymous class in a static context is roughly equivalent to a static nested class in that it does not keep a reference to the enclosing class, even though it's technically not a static class.

Solution 2 - Java

I think there's a bit of confusion in the nomenclature here, which admittedly is too silly and confusing.

Whatever you call them, these patterns (and a few variations with different visibility) are all possible, normal, legal Java:

public class MyClass {
  class MyClassInside {

public class MyClass {
  public static class MyClassInside {

public class MyClass {
  public void method() {
    JComponent jc = new JComponent() {

public class MyClass {
  public static void myStaticMethod() {
    JComponent jc = new JComponent() {

They are catered for in the language spec (if you're really bothered, see section for the one inside the static method).

But this quote is just plain wrong:

> javac.exe will permit anonymous > classes inside static init code and > static methods, even though the > language spec says than anonymous > classes are never static

I think the quoted author is confusing the static keyword with static context. (Admittedly, the JLS is also a bit confusing in this respect.)

Honestly, all of the patterns above are fine (whatever you call them "nested", "inner", "anonymous" whatever...). Really, nobody is going to suddenly remove this functionality in the next release of Java. Honestly!

Solution 3 - Java

Kind of. An anonymous inner class created in a static method will obviously be effectively static because there is no source for an outer this.

There are some technical differences between inner classes in static contexts and static nested classes. If you're interested, read the JLS 3rd Ed.

Solution 4 - Java

Inner classes can't be static - a static nested class is not an inner class. The Java tutorial talks about it here.

Solution 5 - Java

anonymous inner classes are never static (they can't declare static methods or non final static fields),but if they're defined in a static context (static method or static field) they behave as static in the sense that they can't access non-static (i.e. instance) members of the enclosing class (like everything else from a static context)

Solution 6 - Java

On the note of making an anonymous inner class static by calling them within a static method.

This doesn't actually remove the reference. You can test this by trying to serialize the anonymous class and not making the enclosing class serializable.


All content for this solution is sourced from the original question on Stackoverflow.

The content on this page is licensed under the Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license.

Content TypeOriginal AuthorOriginal Content on Stackoverflow
QuestionThiloView Question on Stackoverflow
Solution 1 - JavaMichael MyersView Answer on Stackoverflow
Solution 2 - JavaNeil CoffeyView Answer on Stackoverflow
Solution 3 - JavaTom Hawtin - tacklineView Answer on Stackoverflow
Solution 4 - JavaAndrew DuffyView Answer on Stackoverflow
Solution 5 - JavaLucaView Answer on Stackoverflow
Solution 6 - JavaTerra CainesView Answer on Stackoverflow