Palavras-chave Java Matrizes Java Programação orientada a objetos em Java Manuseio de arquivos Java Introdução ao Java Noções básicas da linguagem Java

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:

Para chamar o construtor da superclasse.
Para acessar um método da superclasse que foi substituído na subclasse.
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;Tecnologia

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

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

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

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

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

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

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.

Java Documentation