Why can't constructors be final, static, or abstract?

Question

When you set a method as final it means: "I don't want any class override it." But according to the Java Language Specification:

JLS 8.8 - "Constructor declarations are not members. They are never inherited and therefore are not subject to hiding or overriding."

When you set a method as abstract it means: "This method doesn't have a body and it should be implemented in a child class." But the constructor is called implicitly when the new keyword is used so it can't lack a body.

When you set a method as static it means: "This method belongs to the class, not a particular object." But the constructor is implicitly called to initialize an object, so there is no purpose in having a static constructor.

The question really is why you want constructor to be static or abstract or final.

Constructors aren't inherited so can't be overridden so whats the use to have final constructor

Constructor is called automatically when an instance of the class is created, it has access to instance fields of the class. What will be the use of a static constructor.

Constructor can't be overridden so what will you do with an abstract constructor.

A Java constructor is implicitly final, the static / non-static aspects of its semantics are implicit¹, and it is meaningless for a Java constructor to be abstract.

This means that the final and static modifiers would be redundant, and the abstract keyword would have no meaning at all.

Naturally, the Java designers didn't see in any point in allowing redundant and/or meaningless access modifiers on constructors ... so these are not allowed by the Java grammar.

Aside: It is a shame that they didn't make the same design call for interface methods where the public and abstract modifiers are also redundant, but allowed anyway. Perhaps there is some (ancient) historical reason for this. But either way, it cannot be fixed without rendering (probably) millions of existing Java programs uncompilable.

---

^{1 - Actually, constructors have a mixture of static and non-static semantics. You can't "call" a constructor on an instance, and it they are not inherited, or overridable. This is similar to the way static methods work. On the other hand, the body of a constructor can refer to this, and call instance methods ... like an instance method. And then there is constructor chaining, which is unique to constructors. But the real point is that these semantics are fixed, and there is no point allowing a redundant and probably confusing static modifier.}

• public constructor: Objects can be created anywhere.

• default constructor: Objects can be created only in the same package.

• protected constructor: Objects can be created by classes outside the package only if it's a subclass.

• private constructor: Object can only be created inside the class (e.g., when implementing a singleton).

The static, final and abstract keywords are not meaningful for a constructor because:

• static members belong to a class, but the constructor is needed to create an object.

• An abstract class is a partially implemented class, which contains abstract methods to be implemented in child class.

• final restricts modification: variables become constant, methods can't be overridden, and classes can't be inherited.

Final: Because you can't overwrite/extend a constructor anyway. You can extend a class (to prevent that you make it final) or overwrite a method (to prevent that you make it final), but there is nothing like this for constructors.

Static: If you look at the execution a constructor is not static (it can access instance fields), if you look at the caller side it is (kind of) static (you call it without having an instance. Its hard to imagine a constructor being completely static or not static and without having a semantic separation between those two things it doesn't make sense to distinguish them with a modifier.

Abstract: Abstract makes only sense in the presence of overwriting/extension, so the same argument as for 'final' applies

No Constructors can NEVER be declared as final. Your compiler will always give an error of the type "modifier final not allowed" Final, when applied to methods, means that the method cannot be overridden in a subclass. Constructors are NOT ordinary methods. (different rules apply) Additionally, Constructors are NEVER inherited. So there is NO SENSE in declaring it final.

1. Constructors are NOT ordinary methods. (different rules apply)
2. Additionally, Constructors are NEVER inherited. So there is NO SENSE in declaring it final. No Constructors can NEVER be declared final. YOur compiler will always give an error of the type "modifer final not allowed"
3. Check the JLS Section 8.8.3 (The JLS & API docs should be some of your primary sources of information).