¿Qué es Constructor en Java?
CONSTRUCTOR es un método especial que se utiliza para inicializar un objeto recién creado y se llama justo después de que se asigna la memoria para el objeto. Se puede utilizar para inicializar los objetos a los valores deseados o valores predeterminados en el momento de la creación del objeto. No es obligatorio que el codificador escriba un constructor para una clase.
Si no se proporciona un constructor definido por el usuario para una clase, el compilador inicializa las variables miembro a sus valores predeterminados.
- los tipos de datos numéricos se establecen en 0
- los tipos de datos char se establecen en un carácter nulo ('\ 0')
- las variables de referencia se establecen en nulo
En este tutorial, aprenderá:
- Reglas para crear un constructor
- Sobrecarga de constructores en Java
- Encadenamiento de constructores
Reglas para crear un constructor de Java
- Tiene el mismo nombre que la clase.
- No debe devolver un valor ni siquiera nulo.
Ejemplo 1 : Cree su primer constructor en Java
Paso 1) Escriba el siguiente programa constructor en el editor de Java.
class Demo{int value1;int value2;Demo(){value1 = 10;value2 = 20;System.out.println("Inside Constructor");}public void display(){System.out.println("Value1 === "+value1);System.out.println("Value2 === "+value2);}public static void main(String args[]){Demo d1 = new Demo();d1.display();}}
Paso 2) Guarde, ejecute y compile el programa constructor en Java y observe el resultado.
Producción:
Inside ConstructorValue1 === 10Value2 === 20
Sobrecarga de constructores en Java
La sobrecarga de constructores de Java es una técnica en la que una clase puede tener cualquier número de constructores que difieran en la lista de parámetros. El compilador diferencia estos constructores teniendo en cuenta el número de parámetros de la lista y su tipo.
Ejemplos de constructores válidos para la clase Account son
Account(int a);Account (int a,int b);Account (String a,int b);
Ejemplo 2 : comprender la sobrecarga de constructores en Java
Paso 1) Escriba el código en el editor.
class Demo{int value1;int value2;/*Demo(){value1 = 10;value2 = 20;System.out.println("Inside 1st Constructor");}*/Demo(int a){value1 = a;System.out.println("Inside 2nd Constructor");}Demo(int a,int b){value1 = a;value2 = b;System.out.println("Inside 3rd Constructor");}public void display(){System.out.println("Value1 === "+value1);System.out.println("Value2 === "+value2);}public static void main(String args[]){Demo d1 = new Demo();Demo d2 = new Demo(30);Demo d3 = new Demo(30,40);d1.display();d2.display();d3.display();}}
Paso 2) Guarde, compile y ejecute el código.
Paso 3) Error =?. Intente depurar el error antes de continuar con el siguiente paso de la sobrecarga del constructor de Java
Paso 4) Cada clase tiene un Constructor predeterminado en Java. El constructor Java sobrecargado predeterminado para la clase Demo es Demo () . En caso de que no proporcione este constructor, el compilador lo crea por usted e inicializa las variables a los valores predeterminados. Puede optar por anular este constructor predeterminado e inicializar las variables a sus valores deseados, como se muestra en el Ejemplo 1.
Pero si especifica un constructor parametrizado como Demo (int a) y desea utilizar el constructor predeterminado Java Demo (), es obligatorio que lo especifique.
En otras palabras, en caso de que se anule el constructor de sobrecarga en Java y desee utilizar el constructor predeterminado Java, es necesario especificarlo.
Paso 5) Descomente la línea # 4-8. Guarde, compile y ejecute el código.
Encadenamiento de constructores
Considere un escenario en el que un niño extiende una clase base. Siempre que se crea un objeto de la clase secundaria, primero se invoca el constructor de la clase principal. Esto se llama encadenamiento de constructores.
Ejemplo 3: comprender el encadenamiento de constructores
Paso 1) Copie el siguiente código en el editor.
class Demo{int value1;int value2;Demo(){value1 = 1;value2 = 2;System.out.println("Inside 1st Parent Constructor");}Demo(int a){value1 = a;System.out.println("Inside 2nd Parent Constructor");}public void display(){System.out.println("Value1 === "+value1);System.out.println("Value2 === "+value2);}public static void main(String args[]){DemoChild d1 = new DemoChild();d1.display();}}class DemoChild extends Demo{int value3;int value4;DemoChild(){//super(5);value3 = 3;value4 = 4;System.out.println("Inside the Constructor of Child");}public void display(){System.out.println("Value1 === "+value1);System.out.println("Value2 === "+value2);System.out.println("Value1 === "+value3);System.out.println("Value2 === "+value4);}}
Paso 2) Ejecute el código. Debido al encadenamiento del constructor, cuando se crea el objeto de la clase secundaria DemoChild, primero se invoca el constructor Demo () de la clase principal y luego se crea el constructor DemoChild () de la secundaria. Salida esperada =
Inside 1st Parent ConstructorInside the Constructor of ChildValue1 === 1Value2 === 2Value1 === 3Value2 === 4
Paso 3) Puede observar que el constructor de la clase principal Demo está anulado. ¿Qué sucede si desea llamar al constructor anulado Demo (int a) en lugar del constructor predeterminado Demo () cuando se crea su objeto hijo?
En tales casos, puede usar la palabra clave "super" para llamar a los constructores reemplazados de la clase principal.
Sintaxis:-
super();--or--super(parameter list);
Ejemplo: Si su constructor es como Demo (String Name, int a) , especificará super ("Java", 5) Si se usa, la palabra clave super debe ser la primera línea de código en el constructor de la clase secundaria.
Paso 4) Descomente la línea # 26 y ejecute el código. Observe la salida.
Producción:
Inside 2nd Parent ConstructorInside the Constructor of ChildValue1 === 5Value2 === 0Value1 === 3Value2 === 4