Tabla de contenidos
¿Qué es un constructor en Java?
CONSTRUCCIÓN es un método especial que se utiliza para iniciar un objeto recién creado y se proporciona inmediatamente después de que la memoria se asigna al objeto. Se puede utilizar para inicializar los objetos a los valores deseados o valores predeterminados cuando se han creado objetos. 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 inicia las variables miembro con sus valores predeterminados.
- los tipos de datos numéricos se establecen en 0
- los tipos de datos char se establecen mediante un carácter nulo (‘ 0’)
- se decide anular las variables de referencia
En este tutorial, aprenderá:
Reglas para crear Java Builder
- Es el mismo nombre como la clase
- Ni siquiera debería devolver valor vacío
Ejemplo 1: Cree su primer constructor en Java
Paso 1) Escriba el siguiente programa de construcción 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 de construcción en Java y vea el resultado.
Producción:
Inside Constructor Value1 === 10 Value2 === 20
Generador de sobrecargas en Java
La sobrecarga de Java Constructor es una técnica en la que la clase de cualquier número de constructores puede diferir 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 cuenta de clase
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 en Java tiene un generador predeterminado. Sobrecarga predeterminada del constructor Java para Demostración en el aula es Exposición (). En caso de que no proporcione este constructor, el compilador lo crea por usted e inicia las variables con los valores predeterminados. Puede optar por anular este constructor predeterminado e iniciar variables en los valores que necesita, como se muestra en el Ejemplo 1.
Pero si especifica un constructor de parámetros como Demo (int a) y desea utilizar el constructor Java Demo () predeterminado, es obligatorio que lo especifique.
Es decir, en caso de que se infrinja su generador de sobrecarga en Java y desee utilizar el generador de Java predeterminado, es necesario especificarlo.
Paso 5) Descomente en línea # 4-8. Guarde, compile y ejecute el código.
Constructor de cadenas
Considere una situación en la que un niño de primaria se estira. Siempre que se crea un objeto de la clase secundaria, primero se invoca al constructor de la clase principal. Se llama Constructor de cadenas.
Ejemplo 3: Entender a un constructor de cadenas
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 clase hijo DemoChild, primero se invoca el constructor Demo () de la clase padre y luego se crea el constructor hijo DemoChild (). Rendimiento esperado
Inside 1st Parent Constructor Inside the Constructor of Child Value1 === 1 Value2 === 2 Value1 === 3 Value2 === 4
Paso 3) Puede observar al constructor de la clase principal de demostración violada. ¿Qué sucede si desea llamar al constructor Demo (int a) predeterminado en lugar del constructor Demo () predeterminado cuando se crea el objeto de su hijo?
En tales casos, puede utilizar la palabra clave «excelente» llamar a los infractores constructores de la clase padre.
Proporción: –
super(); --or-- super(parameter list);
Ejemplo: Si como tu constructor Pantalla (nombre de cadena, int a) tu específicas super («Java», 5) Si se usa, la palabra clave super debe estar en la primera línea de código en el constructor de clases secundarias.
Paso 4) Descomente en línea # 26 y ejecute el código. Mira la salida.
Producción:
Inside 2nd Parent Constructor Inside the Constructor of Child Value1 === 5 Value2 === 0 Value1 === 3 Value2 === 4