super palabra clave para la sobrecarga de métodos en Java

Usamos la sobrecarga de métodos para usar un método similar más de una vez. Esto se puede lograr usando diferentes parámetros en la firma. En el siguiente ejemplo, está disponible una clase GFG con tres métodos similares, aunque los tres métodos están sobrecargados, se proporcionan con diferentes parámetros. El objeto de la clase GFG llama a un método con un parámetro de string.

// Java program to demonstrate the Method
// Overloading without super keyword
 
class GFG {
   
    // Method m1 with 0 parameter.
    public void m1()
    {
        System.out.println("No parameter method");
    }
 
    // Method m1 with 1 integer parameter.
    public void m1(int i)
    {
        System.out.println("Int Parameter");
    }
 
    // Method m1 with 1 string parameter.
    public void m1(String s)
    {
        System.out.println("String Parameter");
    }
}
 
// Main Class
public class Main {
   
    public static void main(String[] args)
    {
        // Creating object for GFG class.
        // g is object of GFG class.
        GFG g = new GFG();
 
        // Here, m1 called with string parameter.
        // m1(String s) method will be called.
        g.m1("A");
    }
}

Producción :

String Parameter

Uso de Superpalabra clave:

Si tanto la clase principal como la secundaria tienen el mismo método, entonces la clase secundaria anularía el método disponible en su clase principal. Al usar la palabra clave super, podemos aprovechar ambas clases (hijo y padre) para lograr esto. 

• Creamos un objeto de clase secundaria ya que puede heredar los métodos de la clase principal.
• En el método de la clase secundaria, llamamos al método disponible en su clase principal usando super().

Nota:

En la clase infantil, se puede dar una palabra clave súper en cualquier línea.

class GFG {
   
    // Method m1 with 0 parameter.
    public void m1()
    {
        System.out.println("No parameter method");
    }
}
 
// tech class extends class GFG
// Using Inheritance concept.
class tech extends GFG {
   
    // Method m1 with 0 parameter.
    public void m1()
    {
        System.out.println("Single Int Parameter");
 
        // Using super keyword to call
        // m1 method from class GFG.
        super.m1();
    }
}
 
// Main Class
public class Main {
    public static void main(String[] args)
    {
        // Creating object for tech class
        // obj is the object for tech class.
        tech obj = new tech();
 
        // tech class method m1
        // will be called here.
        // tech class extends GFG class
 
        // GFG class method m1 will be
        // called inside tech class method m1.
 
        // both method m1 will be called
        // one from tech class and
        // second from GFG class.
        obj.m1();
    }
}

Producción :

Single Int Parameter
No parameter method

En el siguiente ejemplo hemos creado un objeto de Programación que hereda dos clases DP, CP. Cuando se llama al método learn usando el objeto de Programación va a su propia clase Programación, en su clase tenemos super.learn(); que llama al método super.learn() de su clase principal y ahora, después de ir a super.learn() en la clase CP, vuelve a llamar a super.learn() de su clase principal, es decir, desde DP.

// Java program to demonstrate the use
// of super keyword with Method
// Overloading
 
class DP {
    // Class DP method learn
    // with 0 parameter.
    public void learn() { System.out.println("Dynamic"); }
}
 
// Class CP extends class DP
class CP extends DP {
   
    // Class CP method learn
    // with 0 parameter.
    public void learn()
    {
        // Using super keyword
        // here learn will be
        // called from class DP.
        super.learn();
        System.out.println("Competitive");
    }
}
 
// Class programming extends class
// CP that is extends class DP.
class Programming extends CP {
   
    // Class programming method
    // learn with 0 parameter.
    public void learn()
    {
        // Here, learn method from class CP
        // and learn method from class DP
        // which called inside class CP learn
        // method.
        super.learn();
        System.out.println("Programming");
    }
}
 
// Main Class
public class A {
    public static void main(String[] args)
    {
        // Creating object for class Programming.
        Programming obj = new Programming();
        // here, learn method will be called
        // from Programming class.
 
        // method will be also called
        // from programming class extends
        // class CP that is extends
        // class DP.
        obj.learn();
    }
}

Producción:

Dynamic
Competitive
Programming