palavra-chave super em Java

A palavra-chave super em Java é usada para fazer referência ao objeto de classe pai imediato. É comumente usado para acessar métodos e construtores da classe principal, permitindo que uma subclasse herde e reutilize a funcionalidade de sua superclasse.

Uso

A palavra-chave super pode ser usada em três contextos principais:

1. Para chamar o construtor da superclasse.
2. Para acessar um método da superclasse que foi substituído na subclasse.
3. Para acessar um campo da superclasse quando ele estiver oculto por um campo com o mesmo nome na subclasse.

Sintaxe

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

Exemplos

Exemplo 1: Chamando o construtor da superclasse

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

Neste exemplo, a chamada super() no construtor Dog invoca o construtor da classe Animal.

Exemplo 2: Acesso ao método da superclasse

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

Aqui, a chamada super.sound() no método da classe Dog sound() invoca o método sound() da classe Animal.

Exemplo 3: Acesso ao campo da superclasse

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

Neste exemplo, super.color é usado para acessar o campo color da classe Animal, que está oculto pelo campo color na classe Dog.

Dicas e práticas recomendadas

• Encadeamento de construtores: Use super() no construtor de uma subclasse para garantir que o construtor da superclasse seja chamado, permitindo a inicialização adequada do 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");
      }
  }

• Sobreposição de métodos: Use super.methodName() para chamar um método da superclasse quando ele for substituído na subclasse. Isso é útil para estender ou modificar o comportamento do método herdado.  

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

• Acesso ao campo: Use super.fieldName para acessar um campo da superclasse quando ele estiver oculto por um campo com o mesmo nome na subclasse. Isso ajuda a evitar ambiguidades e garante que o campo correto seja acessado.  

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

• Legibilidade: Use o super criteriosamente para tornar seu código mais legível e de fácil manutenção. O uso excessivo do super pode dificultar a compreensão do código.
• Colocação em Construtores: Sempre coloque a chamada super() como a primeira instrução no construtor da subclasse para evitar erros de compilação.
• Contextos estáticos: Lembre-se de que super não pode ser usado em métodos estáticos ou contextos estáticos, pois se refere a uma instância de uma classe.