Uso de la palabra clave super para llamar a un constructor de clase base en Java

Preferimos la herencia para reutilizar el código disponible en las clases existentes. En Java, la herencia es el concepto en el que una clase hereda las propiedades de otra clase. En el siguiente ejemplo, hay dos clases, Programación y DP, mientras que Programación es una clase principal y DP es una clase secundaria. Desde la clase principal, hemos creado un objeto de DP, es decir, una clase secundaria, ya que también nos permite acceder a los métodos de su clase principal, pero si creamos un objeto de la clase principal (Programación), no podemos acceder a los métodos u objetos desde su clase hijo.

Después de crear un objeto de clase secundaria, primero llamamos a un método de la clase secundaria y luego llamamos a un método de la clase principal. Esto no importa ya que podemos llamar a los objetos en cualquier orden.

// Java program to demonstrate inheritance properties
 
class Programming {
   
    // Creating method m1 for class Programming
    public void m1()
    {
      System.out.println("Programming");
    }
}
class DP extends Programming {
   
    // Creating method m2 for class DP
    public void m2()
    {
      System.out.println("DP");
    }
}
public class GFG {
   
    public static void main(String[] args)
    {
        // Creating Obj for Class DP and
        // Calling both m1 from class programming
        // And calling m2 from class DP respectively.
        DP obj = new DP();
        obj.m2();
        obj.m1();
    }
}

Producción :

DP
Programming

Herencia del constructor

En el siguiente ejemplo, hemos creado una clase principal y una secundaria. Aquí, hemos creado un objeto de la clase secundaria, ya que el constructor se llamará a sí mismo al crear un objeto, no necesitamos mencionar nada.

Después de crear un objeto de clase secundaria, se espera que el constructor imprima la salida de su propia clase, pero a partir de la salida, podemos identificar que se ejecutó la clase principal y luego se ejecutó la clase secundaria, esto se debe a que hemos creado un constructor para herencia class y cada clase contiene un super() de forma predeterminada, ya que estamos llamando a una clase heredada que contiene super() en su primera línea y llama a la clase principal.

// Java program to illustrate
// the concept of Constructor
// inheritance.
 
// Base Class
class Programming {
   
    // Constructor for class Programming
    public Programming()
    {
        System.out.println("Programming");
    }
}
 
// Child Class inherit the Base
// Class
class DP extends Programming {
   
    // Constructor for class DP
    public DP() { System.out.println("DP"); }
}
 
// Main Class
public class GFG {
   
    public static void main(String[] args)
    {
        // Creating obj for
        // class DP
        DP obj = new DP();
    }
}

Programming
DP

Sobrecarga del constructor con Super

En el siguiente ejemplo, hemos utilizado el concepto de sobrecarga del constructor, y hemos creado un objeto de clase secundaria y, después de llamar al constructor de la clase secundaria, la primera línea es super(10, 20) que dice que llame al constructor coincidente desde el clase principal, si no mencionamos esa línea, por defecto llama al super() sin constructor parametrizado de la clase principal.

// Java program to demonstrate
// the concepts of constructor
// overloading.
 
// Base Class
class Programming {
   
    // Creating Constructor for
    // class Programming.
    public Programming()
    {
        System.out.println("Programming");
    }
 
    // Parameterized Constructor
    public Programming(int i, int j)
    {
        System.out.println("Programming + +");
    }
}
 
// Child Class
class DP extends Programming {
   
    public DP()
    {
        // Calling by using
        // Programming(int i,int j)
        // from class Programming.
        super(10, 20);
        System.out.println("DP");
    }
 
    // Parameterized Constructor
    // for class DP
    public DP(int i, int j)
    {
        System.out.println("DP + +");
    }
}
 
// Main Class
public class GFG {
    public static void main(String[] args)
    {
        // Creating Object for class DP.
        DP obj = new DP();
    }
}

Producción:

Programming + +
DP

Analogía

Veamos el siguiente fragmento,

• En el siguiente código, hemos creado un objeto de la clase secundaria, y estamos pasando el valor de 10 desde la línea del objeto en sí y, después de ir al constructor específico, primero llama a super() de forma predeterminada e imprime «Programación» desde el padre. clase.
• El punto a tener en cuenta es que estamos llamando a un constructor parametrizado desde la línea de creación de objetos, pero llamará a super() de forma predeterminada, ya que estará disponible de forma predeterminada.
• En la clase secundaria, también podemos dar super() con parámetros para llamar a un constructor específico de la clase principal.

// Base Class
class Programming {
   
    // Default Constructor
    public Programming()
    {
        System.out.println("Programming");
    }
 
    // parameterized Constructor
    public Programming(int i, int j)
    {
        System.out.println("Programming + +");
    }
}
class DP extends Programming {
   
    public DP() { System.out.println("DP"); }
 
    // parameterized Constructor with
    // one parameter
    public DP(int i) { System.out.println("DP +"); }
 
    // parameterized Constructor with
    // two parameter i and j.
    public DP(int i, int j)
    {
        System.out.println("DP + +");
    }
}
 
// Main Class
public class GFG {
   
    public static void main(String[] args)
    {
 
        // Creating obj for DP
        // class which inherits the
        // properties of class programming
        DP obj = new DP(10);
    }
}

Producción :

Programming
DP +