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;Con la tecnología de

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
    }
}Con la tecnología de

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
    }
}Con la tecnología de

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
    }
}Con la tecnología de

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");
      }
  }Con la tecnología de

• 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");
      }
  }Con la tecnología de

• 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
      }
  }Con la tecnología de

• 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.