Introducción al constructor estático en Java
Un constructor estático es el fragmento de código utilizado para inicializar datos estáticos, lo que significa que una tarea en particular solo debe ejecutarse una vez en todo el programa. Por lo general, se llama automáticamente antes de que se haga referencia a cualquier miembro estático o se genera una primera instancia. Un constructor estático es el que se declara explícitamente usando la palabra clave "estática". No se permite que un constructor sea estático, abstracto, final, nativo, sincronizado o estricto en Java.
Tienen algunas características únicas de la siguiente manera:
- Los parámetros o modificadores de acceso no son tomados por un constructor estático.
- Una clase específica solo puede poseer un único constructor estático.
- La herencia o sobrecarga no está permitida en constructores estáticos.
- No se puede invocar directamente ya que siempre se invoca automáticamente.
- Si no se proporcionan los valores de inicialización de los campos estáticos, se inicializa a su valor predeterminado como en la tabla de valores predeterminados.
Sintaxis :
public class (
private ;
public static () ()
)
Aquí estamos tratando de declarar un constructor en la clase definiéndolo como estático. Cuando se compila dicho código, recibimos un mensaje de error que indica que se está utilizando un modificador ilegal para el constructor en tipo y solo se permiten public, protected y private.
Trabajo de constructor estático en Java
Los constructores no pueden ser estáticos en Java debido a la siguiente razón:
En Java, los métodos estáticos y las variables se aplican a las clases. Pero se llama a un constructor cuando se utiliza un nuevo operador para crear una instancia. Como no pertenece a la clase de propiedad, no está permitido que sea estático. Si en caso de que un constructor se considere estático, un objeto de su subclase no puede acceder a él.
Pero si se permite que un constructor sea estático, se puede acceder a él dentro de la clase pero no a su subclase. Tampoco se puede heredar, lo que significa que pertenecen a la clase en la que se declaran. Permitir que un constructor estático incumple todo el concepto de herencia, por lo tanto, es ilegal.
Ejemplos de constructor estático en Java
Podemos entender mejor el concepto de Constructor estático en Java en los siguientes ejemplos:
Ejemplo 1
Código:
public class Employee (
//Initialising variables for employee name and ID
public String emp_name;
public int emp_id;
//Declaration of the static constructor
public static Employee()(
System.out.println("Printing Constructor of the Employee class");
)
//Declaring method to print message
public void displayMsg()(
System.out.println("Employee Name is: "+this.emp_name );
System.out.println("Employee ID is: "+this.emp_id );
)
public static void main(String args()) (
//Creating a new object to call the display message constructor
new Employee().displayMsg();
)
)
Salida:
Aquí estamos obteniendo un error de tiempo de compilación que nos dice que el modificador estático no está permitido para el constructor Employee () dentro de la clase Employee () ya que estamos llamando lo mismo al crear un nuevo objeto a continuación. Esto se puede resolver no declarándolo como estático. Mira el ejemplo a continuación para lo mismo.
Ejemplo # 2
Tenemos que crear 2 clases dentro del mismo paquete; ParentExample.java y ChildExample.java que se extiende desde su clase padre.
Código:
ParentExample.java:
public class ParentExample (
ParentExample()(
super();
System.out.println("Printing Super constructor inside Parent class");
)
void displayMessage()(
System.out.println("Printing inside display Message class");
)
)
ChildExample.java:
public class ChildExample extends ParentExample (
ChildExample()(
super();
System.out.println("Printing super constructor inside child class");
)
@Override
void displayMessage()(
System.out.println("Printing display message inside Parent example");
)
public static void main(String() args)(
ChildExample childexample = new ChildExample();
childexample.displayMessage();
)
)
Ahora ejecute ChildExample.java.
Salida:
Observaciones:
- Tanto la clase principal como la secundaria tienen constructores predeterminados sin argumentos y un mensaje impreso para que el flujo de ejecución sea claro.
- El constructor estático es el primer bloque de código que se ejecuta en la clase, ya que se ejecutan inmediatamente cuando comienza la ejecución de la clase respectiva.
- La subclase anula el método display message () e imprime el mensaje.
- Hemos creado un nuevo objeto de la clase ChildExample que ejecuta el primer constructor de superclase y luego la segunda subclase.
- Finalmente, se invoca el método de visualización del objeto recién creado para mostrar el mensaje.
- En tales casos donde se implementa la herencia, los constructores se llaman explícita o implícitamente. Por lo tanto, debe hacerse no estático para que sea accesible.
- Cuando se hace estático, se asocia con una clase específica que sus instancias y, por lo tanto, no estará disponible durante la creación de instancias de objeto.
Ejemplo # 3
En este ejemplo, combinaremos los dos constructores estáticos y no estáticos anteriores y verificaremos su implementación.
Código:
class ParentClass(
private static String message= "Test message";
// Declaring a nested static class
public static class StaticNestedClass(
// In the nested class only static members belonging to parent class can be accessed
// in a static nested class
public void displayprint() (
// We get a compiler error if we try and make this message
// a non-static variable
System.out.println("Displaying from nested class: " + message);
)
)
// Declaring Inner class or also called non-static nested class
public class ChildClass(
// The static and non-static constructor both can be accessed in
// this Child class
public void displayprint()(
System.out.println("Printing from static non-nested class: "+ message);
)
)
)
class Main
(
public static void main(String args())(
// Instance of static nested class creation
ParentClass.StaticNestedClass printer = new ParentClass.StaticNestedClass();
//Calling the non-static constructor of static nested class
printer.displayprint();
// Creating Parent class instance first in order
//to create the child class instance
ParentClass outer = new ParentClass();
ParentClass.ChildClass inner = outer.new ChildClass();
// Here we call the non-static method of Child class
inner.displayprint();
// Creation of instance for child class in one line
//by combining above 2 lines
ParentClass.ChildClass innerObject = new ParentClass().new ChildClass();
// Now we call the child method
innerObject.displayprint();
)
)
Salida:
Limitaciones del constructor estático en Java
Estas son algunas limitaciones del constructor estático en Java que se detallan a continuación:
- Los nombres de constructor no pueden ser explícitos y debe ser obligatoriamente el mismo que su nombre de clase. Como se limitan a estas convenciones, no se les pueden dar nombres más legibles.
- Cada vez que se necesita llamar a un constructor, se debe crear un nuevo objeto. Esto también afecta el rendimiento del código, lo que lo hace lento.
- Los tipos de retorno de constructores están restringidos para devolver el mismo tipo que el del objeto.
- No podemos usar constructores estáticos en la construcción de subclases ya que solo se permite la implementación de constructores de superclase.
- Un constructor estático no permite el uso de "esta" palabra clave para acceder a una instancia.
- Los esfuerzos de prueba requeridos son más cuando los constructores estáticos están involucrados.
Conclusión
El trabajo principal de un constructor es inicializar un objeto y, como se ve en todos los ejemplos anteriores, no se permite que un constructor sea estático por la razón principal de que no se puede acceder al objeto de una subclase y a otros miembros no estáticos. La alternativa al constructor estático es usar bloques de código estáticos para inicializar variables estáticas de una clase.
Artículos recomendados
Esta es una guía de Static Constructor en Java. Aquí discutimos el funcionamiento, las limitaciones y los ejemplos de constructores estáticos en Java in Java junto con su implementación. También puede consultar los siguientes artículos para obtener más información:
- HashMap en Java
- JavaFX FileChooser
- JavaFX TextField
- Botón JavaFX
- Ejemplos de método estático de JavaScript