Palavra-chave super Java

Neste tutorial, vamos aprender sobre a palavra-chave super em Java através de exemplos.

A palavra-chave super em Java é usada na subclasse para acessar os membros do pai (atributos, construtores e métodos).

Antes de aprender sobre a palavra-chave super, certifique-se de que você já entendeHerança Java。

uso da palavra-chave super

1. 　Chamar o método sobrescrito do pai na subclasse.
   

2. Se a superclasse (superclass) e a subclasse (subclass) tiverem atributos com o mesmo nome, acessar o atributo (campo) da superclasse.

3. Chamar explicitamente o construtor sem parâmetros ou o construtor parametrizado da superclasse a partir do construtor da subclasse.

　 Vamos entender todos esses usos.

1.acesso ao método sobrescrito da superclasse

Se métodos com o mesmo nome forem definidos tanto na superclasse quanto na subclasse, o método na subclasse cobre o método na superclasse. Isso é chamado desobrescrita de método。

示例1: sobrescrita de método

class Animal {
　　//método
　　public void display(){
　　　　System.out.println("Sou um animal");
　　}
}
class Dog extends Animal {
　　//método sobrescrito
　　@Override
　　public void display(){
　　　　System.out.println("Eu sou um cachorro");
　　}
　　public void printMessage(){
　　　　display();
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog dog1　= new Dog();
　　　　cão1.printMessage();
　　}
}

Saída

Eu sou um cachorro

Neste exemplo, criando um objeto da classe Dog chamado dog1， podemos chamar seu método printMessage(), e então esse método executa a instrução display().

Como o método display() está definido em ambas as classes, o método da subclasse Dog sobrescreve o método da superclasse Animal. Portanto, é chamado o método display() da subclasse.

E se precisar chamar o método sobrescrito da superclasse?

Se precisar chamar o método sobrecarregado display() da superclasse Animal, use super.display().

示例2: chamada do método da superclasse

class Animal {
　　//método
　　public void display(){
　　　　System.out.println("Sou um animal");
　　}
}
class Dog extends Animal {
　　//método sobrescrito
　　@Override
　　public void display(){
　　　　System.out.println("Eu sou um cachorro");
　　}
　　public void printMessage(){
　　　　//Isso chama o método sobrescrito
　　　　display();
　　　　//　Isso chama o método da classe pai
　　　　super.display();
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog dog1　= new Dog();
　　　　cão1.printMessage();
　　}
}

Saída

Eu sou um cachorro
Sou um animal

Aqui está como o programa acima funciona.

2.acesso ao atributo super (pai)

A superclasse e a subclasse podem ter atributos com o mesmo nome. Usamos a palavra-chave super para acessar os atributos da superclasse.

示例3: Acesso ao atributo da superclasse

class Animal {
　　protected String type="Animal";
}
class Dog extends Animal {
　　public String type="Mamífero";
　　public void printType() {
　　　　System.out.println("Eu sou "　+　type);
　　　　System.out.println("Eu sou um "　+　super.type);
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog dog1　= new Dog();
　　　　cão1.printType();
　　}
}

输出：

Eu sou um mamífero
Eu sou um animal

在这个实例中，我们在超类Animal和子类Dog中定义了相同的实例字段类型。
然后我们创建了Dog类的对象dog1。然后，使用此对象调用printType()方法。

在printType()函数内部，

• type　 - 指的是子类Dog的属性。

• super.type　 - 指超类Animal的属性。

因此，System.out.println("Eu sou " + type);输出 "Eu sou um mamífero"，并且，System.out.println("Eu sou um " + super.type); imprimir输出 "Eu sou um animal"。

3.使用super()访问超类构造函数

众所周知，创建类的对象时，将自动调用其默认构造函数。

要从子类构造函数中显式调用超类构造函数，我们使用super()。这是super关键字的一种特殊形式。

注意：super() 只能在子类构造函数中使用，并且必须是第一条语句。

示例4：使用super()

class Animal {
　　//Animal类的默认或无参数构造函数
　　Animal() {
　　　　System.out.println("Sou um animal");
　　}
}
class Dog extends Animal {
　　//　Dog类的默认或无参数构造函数
　　Dog() {
　　　　//调用超类的默认构造函数
　　　　super();
　　　　System.out.println("Eu sou um cachorro");
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog dog1　= new Dog();
　　}
}

Saída

Sou um animal
Eu sou um cachorro

在这里，当Dog类的对象dog1被创建时，它会自动调用该类的默认或无参数构造函数。
在子类构造函数中，super()语句调用超类的构造函数并执行其中的语句。因此，我们得到的结果"Sou um animal"。

然后，程序流返回到子类构造函数并执行其余语句。 因此，打印输出"Sou um cão"。

但是，不是必须使用super()。 即使在子类构造函数中没有使用super()，编译器也会隐式调用超类的默认构造函数。

那么，如果编译器自动调用super()，为什么还要显式它，而使用冗余代码呢？

如果必须从子类构造函数中调用超类的参数化构造函数（带有参数的构造函数），则必须显式地使用它。

带参数的super()必须始终是子类的构造函数体中的第一个语句，否则，将出现编译错误。

示例5：使用super()调用参数化构造函数

class Animal {
　　//默认或无参数的构造函数
　　Animal() {
　　　　System.out.println("Sou um animal");
　　}
　　//参数化构造函数
　　Animal(String type) {
　　　　System.out.println("Tipo: ")}+type);
　　}
}
class Dog extends Animal {
　　//Construtor padrão
　　Dog() {
　　　　//Chamada do construtor parametrizado da superclasse
　　　　super("Animal");
　　　　System.out.println("Eu sou um cachorro");
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog dog1　= new Dog();
　　}
}

Saída

Tipo: Animal
Eu sou um cachorro

O compilador pode chamar automaticamente o construtor sem parâmetros. No entanto, ele não pode chamar o construtor com parâmetros.

Se for necessário chamar o construtor parametrizado, ele deve ser definido explicitamente no construtor da subclasse, como na sentença acima do código:

super("Animal");

Atenção, no exemplo acima, usamos super("Animal") para chamar explicitamente o construtor parametrizado. Neste caso, o compilador não chama o construtor padrão da superclasse.