为什么不能从构造函数是私有的类继承？

Question

为什么 Java 不允许从构造函数是私有的类继承？

Answer 1

Java doesn't prevent sub-classing of class with private constructors.

public class Main {
    static class A {
        private A() {
            System.out.println("Subclassed A in "+getClass().getName());
        }
    }

    static class B extends A {
        public B() {

        }
    }

    public static void main(String... ignored) {
        new B();
    }
}

prints

Subclassed A in Main$B

What it prevents is sub-classes which cannot access any constructors of its super class. This means a private constructor cannot be used in another class file, and a package local constructor cannot be used in another package.

In this situation, the only option you have is delegation. You need to call a factory method to create an instance of the "super" class and wrap it.

Answer 2

Because a class must call its super class constructor always . If the super class constructor can't be accessed, then the sub class can't be initialized.

More info: JLS 8.8.10. Preventing Instantiation of a Class

---

Regarding Brian Roach's comments:

The call [to the parent class constructor] is only implicit if you don't do it explicitly and the parent has a public or protected no-arg constructor (or hasn't defined any in which case there's a default no-arg). It's required because ... that's how the language works. Children [classes] must call [their] parent's constructor.

Note that when you instantiate any class in Java, there's always a implicit call to Object constructor since it is the super class of all classes. It will execute its default constructor :

public Object() {
}

Note from the JLS link:

It is a compile-time error if a default constructor is implicitly declared but the superclass does not have an accessible constructor (§6.6) that takes no arguments and has no throws clause.

Answer 3

If constructor of a class is private then child class cannot make call to super constructor. Hence inheritance would fail.

Answer 4

If you have a subclass, you have 2 possiblities for child class(subclass) constructors : 1. Default Constructor(No argument constructor) : In this case default constructor will automatically try to call the parent class constructor : this will fail since parent class constructor is private. 2. Parameterized Constructor : When you try to create an object for a child class which has parameterized constructor, you need to mandatorily call parent class constructor from child class constructor by either passing parameters or not passing parameters : this will also fail since parent constructor is private.

Since child class will have either default constructor or parameterized constructor and its not possible to have either of them, you cannot have a subclass for a parent class with private constructor.

Answer 5

是的，在 Luiggi 的回答中添加了一些东西，在创建单例类时使用了 Java 的这个特性，它只允许创建该类的一个实例。

Answer 6

This is because, When we do inheritance the job of the compiler is to make a direct or indirect relation of all the classes with the Object class by writing the super() at the very first statement of every class constructor . when we make the constructor as private that means it shouldn't be accessed from outside the class but when we do inheritance compiler will implicitly write this type of statement.

class SubClassName extends SuperClassName {
  public SubClassName() {
    super();  // which will indirectly going to call the Parent class constructor from outside its scope
  }
}