Sobrecarga de constructores en Java

¿Qué es la sobrecarga de constructores en Java?

Sobrecarga de constructores en Java Es una técnica en la que una clase declara varios constructores que difieren en la lista de parámetros. El compilador diferencia estos constructores analizando el número de parámetros y sus tipos de datos.

Ejemplos de constructores válidos para la clase Cuenta se muestran a continuación:

Account(int a);
Account (int a,int b);
Account (String a,int b);

¿Por qué necesitamos la sobrecarga de constructores? Java?

Sobrecarga de constructores en Java Mejora la flexibilidad y la eficiencia del código al permitir varios constructores en una clase, cada uno con una lista de parámetros diferente.

• Flexibilidad en la creación de objetos: La sobrecarga de constructores permite inicializar objetos de diversas maneras, dependiendo del número o tipo de parámetros.
• Code Reutilización: Puedes reutilizar la lógica del constructor invocando un constructor desde otro usando el esto() palabra clave.
• Legibilidad mejorada: Los constructores sobrecargados hacen que el código sea más intuitivo al ofrecer opciones específicas para diferentes necesidades de inicialización.
• Inicialización predeterminada y personalizada: La sobrecarga de constructores permite crear fácilmente objetos tanto predeterminados como inicializados de forma personalizada.

Ejemplo: Sobrecarga de constructores en Java

El siguiente ejemplo demuestra la sobrecarga de constructores en Java utilizando una clase llamada Demo.

Paso 1) Escribe 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) Guarda, compila y ejecuta el código.

Paso 3) Aparece un error. Intente depurar el error antes de continuar con el siguiente paso de la sobrecarga del constructor en Java.

Paso 4) Cada clase tiene un valor predeterminado. Constructor en Java. El constructor predeterminado para demostración de clase is Manifestación()Si no lo proporciona, el compilador lo crea por usted e inicializa las variables con valores predeterminados.

Sin embargo, si especifica un constructor parametrizado como Demo(int a) y quiero usar la configuración predeterminada Manifestación(), es obligatorio declararlo explícitamente.

Paso 5) Descomenta las líneas 4 a 8 del código, luego guarda, compila y ejecuta el programa nuevamente para observar el cambio de comportamiento.

Encadenamiento de constructores en Java

Considere un escenario en el que un niño amplía una clase base. Siempre que se crea un objeto de la clase hija, primero se invoca el constructor de la clase padre. Se llama Encadenamiento de constructores.

Ejemplo: Para entender el encadenamiento de constructores con sobrecarga de constructores en Java

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) Ejecuta el código. Debido al encadenamiento de constructores, cuando el objeto de la clase hija DemoChild se crea el constructor Manifestación() de la clase padre se invoca primero y el constructor DemoChild() del niño corre a continuación.

Rendimiento esperado:

Inside 1st Parent Constructor
Inside the Constructor of Child
Value1 === 1
Value2 === 2
Value1 === 3
Value2 === 4

Paso 3) Puede observar que el constructor padre Manifestación() Se ejecuta por defecto. Para llamar al constructor sobrecargado Demo(int a) En su lugar, utilice la palabra clave "súper".

Sintaxis:

super();
--or--
super(parameter list);

Ejemplo: Si su constructor padre es como Demo(String Name, int a), usted especificará súper("Java”,5). Si se utiliza, la palabra clave súper Debe ser la primera línea de código en el constructor de la clase hija.

Paso 4) Descomenta la línea 26 y ejecuta el código. Observa el resultado.

Salida:

Inside 2nd Parent Constructor
Inside the Constructor of Child
Value1 === 5
Value2 === 0
Value1 === 3
Value2 === 4

Preguntas Frecuentes