Neste tutorial, aprenderemos sobre a palavra-chave super em Java com a ajuda de exemplos.
A superpalavra-chave em Java é usada em subclasses para acessar membros da superclasse (atributos, construtores e métodos).
Antes de aprendermos sobre a superpalavra - chave, certifique-se de saber sobre a herança Java.
Usos de superpalavra-chave
- Para chamar métodos da superclasse que é sobrescrita na subclasse.
- Para acessar atributos (campos) da superclasse, se a superclasse e a subclasse tiverem atributos com o mesmo nome.
- Para chamar explicitamente a superclasse no-arg (padrão) ou o construtor parametrizado do construtor da subclasse.
Vamos entender cada um desses usos.
1. Acesse métodos substituídos da superclasse
Se métodos com o mesmo nome forem definidos na superclasse e na subclasse, o método na subclasse substituirá o método na superclasse. Isso é chamado de substituição de método.
Exemplo 1: Substituição de método
class Animal ( // overridden method public void display()( System.out.println("I am an animal"); ) ) class Dog extends Animal ( // overriding method @Override public void display()( System.out.println("I am a dog"); ) public void printMessage()( display(); ) ) class Main ( public static void main(String() args) ( Dog dog1 = new Dog(); dog1.printMessage(); ) )
Resultado
eu sou um cão
Neste exemplo, ao criar um objeto dog1 da classe Dog, podemos chamar seu método printMessage () que então executa a display()instrução.
Como display()é definido em ambas as classes, o método da subclasse Dog substitui o método da superclasse Animal. Conseqüentemente, o display()da subclasse é chamado.
E se o método sobrescrito da superclasse tiver que ser chamado?
Usaremos super.display()se o método sobrescrito display()da superclasse Animal precisar ser chamado.
Exemplo 2: super para chamar o método da superclasse
class Animal ( // overridden method public void display()( System.out.println("I am an animal"); ) ) class Dog extends Animal ( // overriding method @Override public void display()( System.out.println("I am a dog"); ) public void printMessage()( // this calls overriding method display(); // this calls overridden method super.display(); ) ) class Main ( public static void main(String() args) ( Dog dog1 = new Dog(); dog1.printMessage(); ) )
Resultado
Eu sou um cachorro sou um animal
Veja como funciona o programa acima.
2. Atributos de acesso da superclasse
A superclasse e a subclasse podem ter atributos com o mesmo nome. Usamos a superpalavra-chave para acessar o atributo da superclasse.
Exemplo 3: Acesso ao atributo superclasse
class Animal ( protected String; ) class Dog extends Animal ( public String; public void printType() ( System.out.println("I am a " + type); System.out.println("I am an " + super.type); ) ) class Main ( public static void main(String() args) ( Dog dog1 = new Dog(); dog1.printType(); ) )
Produto :
Eu sou um mamífero sou um animal
Neste exemplo, definimos o mesmo tipo de campo de instância na superclasse Animal e na subclasse Dog.
Em seguida, criamos um objeto dog1 da classe Dog. Em seguida, o printType()método é chamado usando este objeto.
Dentro da printType()função,
- tipo refere-se ao atributo da subclasse Dog.
- super.tipo refere-se ao atributo da superclasse Animal.
Portanto, System.out.println("I am a " + type);imprime eu sou um mamífero. E, System.out.println("I am an " + super.type);imprime eu sou um animal.
3. Uso de super () para acessar o construtor da superclasse
Como sabemos, quando um objeto de uma classe é criado, seu construtor padrão é automaticamente chamado.
Para chamar explicitamente o construtor da superclasse a partir do construtor da subclasse, usamos super(). É uma forma especial da superpalavra - chave.
super() pode ser usado apenas dentro do construtor da subclasse e deve ser a primeira instrução.
Exemplo 4: uso de super ()
class Animal ( // default or no-arg constructor of class Animal Animal() ( System.out.println("I am an animal"); ) ) class Dog extends Animal ( // default or no-arg constructor of class Dog Dog() ( // calling default constructor of the superclass super(); System.out.println("I am a dog"); ) ) class Main ( public static void main(String() args) ( Dog dog1 = new Dog(); ) )
Resultado
Eu sou um animal sou um cachorro
Aqui, quando um objeto dog1 da classe Dog é criado, ele chama automaticamente o construtor padrão ou sem arg dessa classe.
Dentro do construtor da subclasse, a super()instrução chama o construtor da superclasse e executa as instruções dentro dele. Portanto, obtemos a saída Eu sou um animal.
O fluxo do programa então retorna ao construtor da subclasse e executa as instruções restantes. Assim, eu sou um cachorro será impresso.
No entanto, o uso super()não é obrigatório. Mesmo se super()não for usado no construtor da subclasse, o compilador chama implicitamente o construtor padrão da superclasse.
Então, por que usar código redundante se o compilador invoca automaticamente super ()?
É necessário se o construtor parametrizado (um construtor que recebe argumentos) da superclasse tiver que ser chamado a partir do construtor da subclasse.
O parametrizado super()deve ser sempre a primeira instrução no corpo do construtor da subclasse, caso contrário, obteremos um erro de compilação.
Exemplo 5: chamar o construtor parametrizado usando super ()
class Animal ( // default or no-arg constructor Animal() ( System.out.println("I am an animal"); ) // parameterized constructor Animal(String type) ( System.out.println("Type: "+type); ) ) class Dog extends Animal ( // default constructor Dog() ( // calling parameterized constructor of the superclass super("Animal"); System.out.println("I am a dog"); ) ) class Main ( public static void main(String() args) ( Dog dog1 = new Dog(); ) )
Resultado
Tipo: Animal Eu sou um cachorro
O compilador pode chamar automaticamente o construtor no-arg. No entanto, ele não pode chamar construtores parametrizados.
Se um construtor parametrizado tiver que ser chamado, precisamos defini-lo explicitamente no construtor da subclasse.
Observe que, no exemplo acima, chamamos explicitamente o construtor parametrizado super("Animal"). O compilador não chama o construtor padrão da superclasse neste caso.
