super Palabra clave en Java

La palabra clave super en Java se utiliza para referirse al objeto de clase padre inmediato. Se suele utilizar para acceder a los métodos y constructores de la clase padre, lo que permite a una subclase heredar y reutilizar la funcionalidad de su superclase.

Utilización

La palabra clave super puede utilizarse en tres contextos principales:

1. Para llamar al constructor de la superclase.
2. Para acceder a un método de la superclase que ha sido sobrescrito en la subclase.
3. Para acceder a un campo de la superclase cuando está oculto por un campo del mismo nombre en la subclase.

Syntax

super();
super.methodName();
super.fieldName;

Ejemplos

Ejemplo 1: Llamada al constructor de la superclase

class Animal {
    Animal() {
        System.out.println("Animal constructor called");
    }
}

class Dog extends Animal {
    Dog() {
        super(); // Calls the constructor of Animal class
        System.out.println("Dog constructor called");
    }
}

public class TestSuper {
    public static void main(String[] args) {
        Dog d = new Dog(); // Output: Animal constructor called
                          //         Dog constructor called
    }
}

En este ejemplo, la llamada a super() en el constructor de Dog invoca al constructor de la clase Animal.

Ejemplo 2: Acceso al método de la superclase

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    void sound() {
        super.sound(); // Calls the sound() method of Animal class
        System.out.println("Dog barks");
    }
}

public class TestSuper {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.sound(); // Output: Animal makes a sound
                   //         Dog barks
    }
}

Aquí, la llamada super.sound() del método sound() de la clase Dog invoca al método sound() de la clase Animal.

Ejemplo 3: Acceso al campo Superclase

class Animal {
    String color = "white";
}

class Dog extends Animal {
    String color = "black";

    void displayColor() {
        System.out.println("Dog color: " +// Prints the color of Dog class
        System.out.println("Animal color: " + super.// Prints the color of Animal class
    }
}

public class TestSuper {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.displayColor(); // Output: Dog color: black
                          //         Animal color: white
    }
}

En este ejemplo, super.color se utiliza para acceder al campo color de la clase Animal, que está oculto por el campo color de la clase Dog.

Consejos y buenas prácticas

• Encadenamiento de constructores: Utiliza super() en el constructor de una subclase para asegurarte de que se llama al constructor de la superclase, permitiendo la correcta inicialización del objeto.  

  class Parent {
      Parent() {
          System.out.println("Parent constructor");
      }
  }
  
  class Child extends Parent {
      Child() {
          super(); // Always the first statement in the constructor
          System.out.println("Child constructor");
      }
  }

• Anulación de métodos: Utiliza super.methodName() para llamar a un método de la superclase cuando se sobrescribe en la subclase. Esto es útil para ampliar o modificar el comportamiento del método heredado.  

  class Parent {
      void display() {
          System.out.println("Parent display");
      }
  }
  
  class Child extends Parent {
      void display() {
          super.display(); // Calls Parent's display method
          System.out.println("Child display");
      }
  }

• Acceso al campo: Utiliza super.fieldName para acceder a un campo de la superclase cuando esté oculto por un campo del mismo nombre en la subclase. Esto ayuda a evitar ambigüedades y garantiza que se accede al campo correcto.  

  class Parent {
      int number = 10;
  }
  
  class Child extends Parent {
      int number = 20;
  
      void showNumber() {
          System.out.println(super.number); // Accesses Parent's number
      }
  }

• Legibilidad: Utiliza super juiciosamente para que tu código sea más legible y fácil de mantener. El uso excesivo de super puede dificultar la comprensión del código.
• Colocación en Constructores: Coloca siempre la llamada a super() como primera sentencia en el constructor de la subclase para evitar errores de compilación.
• Contextos estáticos: Recuerda que super no puede utilizarse en métodos estáticos ni en contextos estáticos, ya que se refiere a una instancia de una clase.