Sobrecarga de constructores en Java

¿Qué es la sobrecarga de constructores? Java?

Java La sobrecarga de constructores es una técnica en la que una clase puede tener cualquier número de constructores que difieren 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 Cuenta son

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

Ejemplo : Para comprender la sobrecarga de constructores en Java

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) Guarde, compile y ejecute el código.

Paso 3) Error=?. Intente depurar el error antes de continuar con el siguiente paso de Java sobrecarga del constructor

Paso 4) Cada clase tiene un valor predeterminado. Constructor en Java. Constructor sobrecargado predeterminado Java demostración de clase is Manifestación(). En caso de que no proporcione este constructor, el compilador lo crea por usted e inicializa las variables con los valores predeterminados. Puede optar por anular este constructor predeterminado e inicializar las variables con los 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 especifiques.

En otras palabras, en caso de que su constructor sobrecargado en Java está anulado y desea utilizar el constructor predeterminado Java, es necesario especificarlo.

Paso 5) Descomente la línea # 4-8. Guarde, compile y ejecute el código.

¿Por qué necesitamos una sobrecarga de constructores en Java?

Sobrecarga del constructor en Java Permite múltiples constructores en una clase, cada uno con diferentes listas de parámetros. Mejora la flexibilidad y la eficiencia del código.

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

Preguntas Frecuentes

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();
  }
}

Inside Constructor
Value1 === 10
Value2 === 20

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);
   }
}

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

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

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