Can't call constructor of inner class in a static context -- "non-static variable this cannot be referenced from a static context"

Question

I have an OuterClass and an NestedClass. Like this.

public class OuterClass
{

        public class NestedClass
        {



        }

}

Whenever I try to call the constructor of NestedClass in a static context (like as a static field or a static method), I get a compiler error.

Here is an example code.

public class OuterClass
{

        public class NestedClass
        {

                public static final NestedClass someStaticField = new NestedClass();

                public static NestedClass someStaticMethod()
                {

                        return new NestedClass();

                }

        }

}

And here are the compiler errors that I get.

$ javac OuterClass.java
OuterClass.java:7: error: non-static variable this cannot be referenced from a static context
                public static final NestedClass someStaticField = new NestedClass();
                                                                 ^
OuterClass.java:12: error: non-static variable this cannot be referenced from a static context
                        return new NestedClass();
                               ^
2 errors

What do these errors mean, and what should I be writing instead to achieve the desired outcome of being able to call the constructor in a static context?

Answer 1

The problem is that the NestedClass is not static - neither implicitly nor explicitly declared as such - so it is an inner class. From Java Language Specification 8.1.3. Inner Classes and Enclosing Instances:

An inner class is a nested class that is not explicitly or implicitly static.

To create an instance of such inner class, an instance of the enclosing (outer class) is needed. If not in a static context, this is implicitly used when creating such an instance. In a static context, there is no this and we must provide the instance of the enclosing class. This is accomplish by using a qualified class instance creation expression like:

outer.new InnerClass()

as described in JLS 15.9. Class Instance Creation Expressions:

A qualified class instance creation expression enables the creation of instances of inner member classes and their anonymous subclasses.

More details can be found in JLS 15.9.2. Determining Enclosing Instances.

---

Applying that to the code of the question, we could do:

public class OuterClass
{

    public class NestedClass // actually an Inner Class
    {
        public static final NestedClass someStaticField = new OuterClass().new NestedClass();

        public static NestedClass someStaticMethod()
        {
            var outer = new OuterClass();
            return outer.new NestedClass();
        }
    }
}

A second possibility would be to not make the nested class an inner class by declaring it as static and avoiding the need for an enclosing instance:

public class OuterClass
{

    // static added to following declaration
    public static class NestedClass
    {
        public static final NestedClass someStaticField = new NestedClass();

        public static NestedClass someStaticMethod()
        {
            return new NestedClass();
        }
    }
}

Which solution to use should be based on the specific use case and data model, not just because the compiler accepts it!

---

Note: static members of inner classes are allowed since Java 16 (JEP 359), so we can have record classes, which are static, declared in inner classes.

Answer 2

Long story short, the problem is because, in Java, if my NestedClass does not have a static modifier up front, then it is considered an Inner Class, and Inner Classes are not allowed to have static fields or methods. So, if I want my NestedClass to have static fields or methods, then I must make my NestedClass a Static Nested Class. Meaning, I need to put a static modifier in front of the class on my NestedClass.

Here is the change.

BEFORE -- public class NestedClass
AFTER  -- public static class NestedClass

---

And for the long version, here is a great tutorial by Oracle themselves that walks you through the concept.

https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html

In short, if there is a class B that is inside of class A, then class B is considered a Nested Class.

There are 2 types of Nested Classes -- Inner Classes and Static Nested Classes.

Inner Classes are when the class is defined the way I did above -- one class inside of another. In the immediate example, class B would NOT have a static modifier in front of it.

Static Nested Classes are the exact same as Inner Classes, but they DO have a static modifier in front of it.

So for example.

public class OuterClass
{

        //    not static!
        public class InnerClass
        {

                public static final InnerClass someStaticField = new InnerClass();

                public static InnerClass someStaticMethod()
                {

                        return new InnerClass();

                }

        }
        
        //     static! -- If you don't put the static keyword, then it's not a static class!
        public static class StaticNestedClass
        {

                public static final StaticNestedClass someStaticField = new StaticNestedClass();

                public static StaticNestedClass someStaticMethod()
                {

                        return new StaticNestedClass();

                }


        }

}

If I try to compile this, my InnerClass gets the same 2 compilation errors (like in my question), but my StaticNestedClass gets NO COMPILATION ERRORS!

The reason for this is that Static Nested Classes are allowed to have static fields/methods, but Inner Classes are not allowed to have static fields/methods.

This is a strict rule. That means, the only way I can possibly get my NestedClass to have a static field or method is by turning that Inner Class into a Static Nested Class, and that is done by putting the static keyword in front of the class keyword.

Here is the fixed version.

public class OuterClass
{

        //now its static!
        public static class NestedClass
        {

                public static final NestedClass someStaticField = new NestedClass();

                public static NestedClass someStaticMethod()
                {

                        return new NestedClass();

                }

        }

}

No more compilation errors!