¿Por qué un Constructor no puede ser final, estático o abstracto en Java?

Requisito previo: Herencia en Java

Constructor en Java es un tipo especial de método que es diferente de los métodos normales de Java/métodos ordinarios. Los constructores se utilizan para inicializar un objeto. Automáticamente se llama a un constructor cuando se crea un objeto de una clase. Es sintácticamente similar a un método pero tiene el mismo nombre que su clase y un constructor no tiene un tipo de retorno. 

El constructor de Java no puede ser definitivo

Una de las propiedades importantes del constructor java es que no puede ser final . Como sabemos, los constructores no se heredan en java . Por lo tanto, los constructores no están sujetos a ocultación o anulación . Cuando no hay posibilidad de anulación del constructor, tampoco hay posibilidad de modificación. Cuando no hay posibilidad de modificación, entonces no hay sentido de restringir la modificación allí. Sabemos que la palabra clave final restringe más modificaciones. Entonces, un constructor de Java no puede ser definitivo porque inherentemente no se puede modificar. Además, un constructor de Java es internamente final. Así que de nuevo no hay necesidad de más declaración final. 

Ejemplo: supongamos que estamos declarando un constructor de java como final, ahora veamos qué sucede.

// Java Constructor as final
 
import java.io.*;
class GFG {
 
    // GFG() constructor is declared final
    final GFG()
    {
        // This line can not be executed as compile error
        // will come
        System.out.print(
            "Hey you have declared constructor as final, it's error");
    }
}
class Main {
    public static void main(String[] args)
    {
        // Object of GFG class created
        // Automatically GFG() constructor called
        GFG obj = new GFG();
    }
}

 
Producción: 

prog.java:4: error: modifier final not allowed here
final GFG( )
      ^
1 error

Del ejemplo anterior también queda claro que si estamos definiendo constructor como final, el compilador dará un error como modificador final no permitido .

El constructor de Java no puede ser estático 

Una de las propiedades importantes del constructor java es que no puede ser estático . Sabemos que la palabra clave estática pertenece a una clase en lugar del objeto de una clase. Se llama a un constructor cuando se crea un objeto de una clase, por lo que no se usa el constructor estático. Otra cosa es que si declaramos un constructor estático, entonces no podemos acceder/llamar al constructor desde una subclase. Porque sabemos que la estática está permitida dentro de una clase pero no por una subclase.

Ejemplo:

// java class and a subclass
 
import java.io.*;
 
class GFG {
    public GFG()
    {
        // Constructor of GFG class
        System.out.println("GFG Constructor");
    }
}
class SubClass extends GFG {
 
    SubClass()
    {
        // Constructor of SubClass class
        // By default super() is hidden here
        // So Super class i.e GFG class constructor called
        System.out.println("Subclass Constructor");
    }
    public static void main(String args[])
    {
        // SubClass class object created
        // Automatically SubClass() constructor called
        SubClass obj = new SubClass();
    }
}

GFG Constructor
Subclass Constructor

El ejemplo anterior expresa que, cuando se crea un objeto de subclase, el constructor de subclase llama al constructor de superclase a través del enstringmiento de constructores. Pero si hacemos que el constructor de la superclase sea estático, entonces no puede ser llamado por Subclase como se dijo anteriormente estático, es accesible dentro de la clase pero no por la subclase .

Otra razón importante para no declarar el constructor como estático es que sabemos que un miembro estático se ejecuta primero en un programa, al igual que el método principal, que es estático y se ejecuta primero. Pero se llama al constructor cada vez que se crea un objeto. Pero si lo declaramos estático, se llamará al constructor antes de la creación del objeto. Entonces, en general, si vemos que static y constructor son opuestos entre sí, si queremos asignar valores iniciales para una variable de instancia, podemos usar constructor y si queremos asignar variables estáticas, podemos usar bloques estáticos. 

Ejemplo: supongamos que estamos declarando un constructor de Java como estático, ahora veamos qué sucede.

// java constructor as static
 
import java.io.*;
 
class GFG {
   
    // GFG() constructor is declared static
    static GFG()
    {
        // This line can not be executed as it compile error
        // will come
        System.out.print(
            "Hey you have declared constructor as static, it's error");
    }
}
class Main {
    public static void main(String[] args)
    {
        // Object of GFG class created
        // Automatically GFG() constructor called
        GFG obj = new GFG();
    }
}

 
Producción:

prog.java:5: error: modifier static not allowed here
 static GFG( )
        ^
1 error

Del ejemplo anterior también queda claro que si estamos definiendo el constructor como estático, el compilador dará un error como modificador estático no permitido.

El constructor de Java no puede ser abstracto. 

Una de las propiedades importantes del constructor java es que no puede ser abstracto . Si estamos declarando un constructor tan abstracto, tenemos que implementarlo en una clase secundaria, pero sabemos que un constructor se llama implícitamente cuando se usa la nueva palabra clave, por lo que no puede carecer de cuerpo y tampoco se puede llamar como un método habitual. Además, si hacemos que un constructor sea abstracto, debemos proporcionar el cuerpo más adelante. Pero sabemos que el constructor no se puede anular, por lo que es imposible proporcionar el cuerpo. Por lo tanto, qué haremos con este constructor abstracto cuando no podamos implementarlo.

Ejemplo: supongamos que estamos declarando un constructor de Java como abstracto, ahora veamos qué sucede

// java constructor as static
 
import java.io.*;
abstract class GFG {
   
    // GFG() constructor is declared abstract
    abstract GFG()
    {
        // This line can not be executed as compile error
        // will come
        System.out.print(
            "Hey you have declared constructor as abstract, it's error");
    }
}
class Main {
    public static void main(String[] args)
    {
        // Object of GFG class created
        // Automatically GFG() constructor should be called
        // But object creation in abstract class is error
        GFG obj = new GFG();
    }
}

Producción: 

prog.java:5: error: modifier abstract not allowed here
 abstract GFG( )
          ^
prog.java:17: error: GFG is abstract; cannot be instantiated
   GFG obj = new GFG();
             ^
2 errors

Del ejemplo anterior también queda claro que si estamos definiendo el constructor como abstracto, el compilador dará un error como modificador abstracto no permitido.

Nota: la interfaz de Java no puede tener un constructor, pero las clases abstractas pueden tener un constructor .