Private constructor of static inner classes in Java

Question

I'm new to Java and I see that we cannot subclass a class that has its constructor as private. However, I came across this code which creates a subclass whose super class' constructor is private.

In short:

This works:

class A {
    static class B {
        private B() {
            out.println("Constructor of B");
        }
    }

    static class C extends B {
        C() {
            out.println("Constructor of C");
        }
    }
}

While this doesn't:

class B {
    private B() {
        out.println("Constructor of B");
    }
}

class C extends B {
    C() {
        out.println("Constructor of C"); // No default constructor available for super class
    }
}

Can anyone please help me understand what's going on here?

*we cannot subclass a class that has its constructor as `private`*: I think that is not quite accurate. It should be *...that has no constructor that is accessible to the subclass*. In this case (the working code), `C` has access to `private` members of `B` — ernest_k, Jan 23 '20 at 16:34

score 5 · Accepted Answer · answered Jan 23 '20 at 16:31

There's a subtlety about private that you may not have grokked yet. From JLS 6.6:

Otherwise, the member or constructor is declared private, and access is permitted if and only if it occurs within the body of the top level type (§7.6) that encloses the declaration of the member or constructor.

So forgetting about inheritance for the moment, that means that all the code within a top-level type, including the code within nested types, has access to all the private members declared within the same top-level type, including members declared within nested types.

Here's an example of that:

public class TopLevel {

    private static void foo() {
    }

    static class Nested1 {
        private static void bar() {
        }
    }

    static class Nested2 {
        private static void callFooBarFromNested() {
            foo();
            Nested1.bar();
        }
    }

    private static void callFooBarFromTopLevel() {
        foo();
        Nested1.bar();
    }
}

From there, it's only a small step to see why your first example is fine - the parameterless constructor in C needs to chain to the parameterless constructor in B, which it can do when they're both nested in the same top-level class, but not otherwise.

Private constructor of static inner classes in Java

1 Answers1