在Java中，子类可以通过使用super关键字来调用父类的函数。这种特性被称为方法重写或方法覆盖。super关键字是一个引用变量，被用来引用父类的对象，可以调用父类的方法和变量、当在子类中需要使用父类的方法时，可以使用super.method()的形式、当子类中有与父类同名的方法时，使用super关键字可以避免自我引用。
在Java的面向对象编程中，类的继承是一个重要特性，它允许我们在子类中重用父类的代码。在实际编程过程中，我们经常需要在子类中调用父类的方法，特别是当子类需要扩展或修改父类方法的功能时。这个时候，我们就需要使用到super关键字。
一、SUPER关键字的使用
在Java中，super关键字是一个特殊的引用，它被用来引用父类的对象。使用super关键字，我们可以在子类中调用父类的方法。例如，假设我们有一个父类Person和一个子类Student，如下所示：
class Person {
void message() {
System.out.println("This is person class");
}
}
class Student extends Person {
void message() {
System.out.println("This is student class");
}
void display() {
message(); // will invoke the current class method
super.message(); // will invoke the parent class method
}
}
public class Test {
public static void main(String args[]) {
Student s = new Student();
s.display();
}
}
在上面的代码中，我们在子类Student中重写了父类Person的message()方法。在display()方法中，我们分别调用了子类和父类的message()方法，可以看到，当我们需要调用父类的方法时，只需要在方法前加上super关键字即可。
二、方法重写和SUPER关键字
当子类需要修改或扩展父类的某个方法时，我们通常会在子类中重写这个方法。但是，有时候我们可能还需要调用父类原来的方法，这时我们就需要使用到super关键字。
例如，假设我们有一个父类Car和一个子类ElectricCar，如下所示：
class Car {
void run() {
System.out.println("Car is running");
}
}
class ElectricCar extends Car {
void run() {
super.run();
System.out.println("ElectricCar is running");
}
}
public class Test {
public static void main(String args[]) {
ElectricCar ec = new ElectricCar();
ec.run();
}
}
在上面的代码中，我们在子类ElectricCar中重写了父类Car的run()方法。在重写的run()方法中，我们首先通过super.run()调用了父类的run()方法，然后输出了"ElectricCar is running"。当我们运行这段代码时，会先输出"Car is running"，然后输出"ElectricCar is running"。这说明，我们成功地在子类中调用了父类的方法。
三、避免自我引用
在Java中，如果在子类中有一个与父类同名的方法，那么在子类中调用这个方法时，实际上是在调用子类自己的方法，而不是父类的方法。这时，我们就需要使用super关键字来避免自我引用。
例如，假设我们有一个父类Animal和一个子类Dog，如下所示：
class Animal {
void eat() {
System.out.println("Animal is eating");
}
}
class Dog extends Animal {
void eat() {
System.out.println("Dog is eating");
}
void eatTest() {
this.eat(); // this calls own method
super.eat(); // super calls parent method
}
}
public class Test {
public static void main(String args[]) {
Dog d = new Dog();
d.eatTest();
}
}
在上面的代码中，我们在子类Dog中重写了父类Animal的eat()方法。在eatTest()方法中，我们通过this.eat()调用了子类自己的eat()方法，然后通过super.eat()调用了父类的eat()方法。当我们运行这段代码时，会先输出"Dog is eating"，然后输出"Animal is eating"。这说明，通过使用super关键字，我们成功地在子类中调用了父类的方法，避免了自我引用。
总结，Java中的super关键字为我们提供了一种方便的方式来在子类中调用父类的方法。不仅如此，当子类中有与父类同名的方法时，使用super关键字还可以避免自我引用。然而，需要注意的是，super关键字只能在子类中使用，不能在同一类中使用。而且，当我们调用父类的方法时，必须保证这个方法在父类中已经被定义。
相关问答FAQs：
1. 如何在Java子类中调用父类的函数？在Java中，子类可以通过使用super关键字来调用父类的函数。通过super关键字，子类可以访问父类中被继承的方法，无论这些方法是公有的、私有的还是受保护的。
2. 子类如何重写父类的函数并调用父类的函数？如果子类想要重写父类的函数，可以在子类中使用与父类相同的函数名和参数列表进行方法重写。然后，可以使用super关键字在子类中调用父类的函数，以便在子类中执行父类的逻辑。
3. 子类如何调用父类的构造函数？在Java中，子类可以使用super关键字来调用父类的构造函数。通过在子类的构造函数中使用super关键字，子类可以调用父类的构造函数，并传递相应的参数。这样做可以确保子类在实例化时，可以先执行父类的构造函数，然后再执行子类自身的构造逻辑。
文章包含AI辅助创作，作者：Edit2，如若转载，请注明出处：https://docs.pingcode.com/baike/283805