Java super
Super Java
Neste tutorial, aprenderemos sobre a palavra-chave super em Java com a ajuda de exemplos.
O
super palavra-chave em Java é usada em subclasses para acessar membros da superclasse (atributos, construtores e métodos). Antes de aprendermos sobre o
super palavra-chave, certifique-se de saber sobre herança Java. Usos de superpalavra-chave
- Para chamar métodos da superclasse que é substituída 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 construtor parametrizado do construtor da subclasse.
Vamos entender cada um desses usos.
1. Acesse os 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();
}
}
Saída
I am a dog
Neste exemplo, fazendo um objeto dog1 de Cão classe, podemos chamar seu método printMessage() que então executa o
display() declaração. Desde
display() é definido em ambas as classes, o método da subclasse Dog sobrescreve o método da superclasse Animal . Portanto, o display() da subclasse é chamado. 
E se o método substituído da superclasse tiver que ser chamado?
Usamos
super.display() se o método substituído display() da superclasse Animal precisa 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();
}
}
Saída
I am a dog I am an animal
Aqui, como funciona o programa acima.
2. Atributos de acesso da superclasse
A superclasse e a subclasse podem ter atributos com o mesmo nome. Usamos o
super palavra-chave para acessar o atributo da superclasse. Exemplo 3:Acessar atributo de superclasse
class Animal {
protected String type="animal";
}
class Dog extends Animal {
public String type="mammal";
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();
}
}
Saída :
I am a mammal I am an animal
Neste exemplo, definimos o mesmo campo de instância type tanto na superclasse Animal e a subclasse Cão .
Em seguida, criamos um objeto dog1 do Cão classe. Em seguida, o
printType() método é chamado usando este objeto. Dentro do
printType() função, - tipo refere-se ao atributo da subclasse Cão .
- super.type refere-se ao atributo da superclasse Animal.
Portanto,
System.out.println("I am a " + type); imprime
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 é chamado automaticamente.
Para chamar explicitamente o construtor da superclasse do construtor da subclasse, usamos
super() . É uma forma especial do super palavra-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();
}
}
Saída
I am an animal I am a dog
Aqui, quando um objeto dog1 de Cão classe é criada, ela chama automaticamente o construtor padrão ou sem argumentos dessa classe.
Dentro do construtor da subclasse, o
super() A instrução chama o construtor da superclasse e executa as instruções dentro dela. Assim, obtemos a saída
I am an 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, usando
super() não é obrigatório. Mesmo que super() não é 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 deve ser chamada a partir do construtor da subclasse.
O
super() parametrizado 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 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();
}
}
Saída
Type: Animal I am a dog
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. Java