“这里是云端源想IT，帮你轻松学IT”

嗨~ 今天的你过得还好吗？

别人的屋檐再大

都不如自己有把伞

- 2023.08.30 -

在Java和其他一些高级面向对象的编程语言中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。

在Java中，方法重写（Overriding）是子类重新定义其父类已有方法的能力。通过方法重写，我们可以实现类似继承的功能，同时还可以实现更高的灵活性和可扩展性。本篇文章我们将探讨Java中方法重写的概念、规则和注意事项，并提供一些实际的示例来帮助你更好地理解和应用它。

一、Java方法重写的概念

子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

方法重写的应用场景：

子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

Override注解：

@Override：注解，重写注解校验！

这是注解标记的方法，就说明这个方法必须是重写父类的方法，否则编译阶段报错。

建议重写都加上这个注解，一方面可以提高代码的可读性，一方面可以防止重写出错！

子类重写父类方法的时候，访问权限需要大于等于父类。

重写&重载：

方法重写：子类和父类出现了一模一样的方法声明（方法名、参数类表、返回值类型）。

方法重载：在同一个类中，方法名相同，参数列表不同，与返回值无关。

注意：

• 私有方法不能被重写(父类私有成员子类是不能继承的)；
• 子类方法访问权限不能更低(public > protected > default > private)；

• 父类中的静态方法不能被重写，如果子类也有相同的方法，并不是重写的父类的方法，而是将父类同名的方法隐藏了起来。

下面看个例子：

private void show() {
System.out.println("Fu中show()方法被调用");
}

void method(int a ) {
System.out.println("Fu中method()方法被调用");
}

static void method2() {
System.out.println("Fu中method2()方法被调用");
}
}

public class Zi extends Fu {

// 编译【出错】，子类不能重写父类私有的方法
@Override
private void show() {
System.out.println("Zi中show()方法被调用");
}

// 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类
@Override
private void method() {
System.out.println("Zi中method()方法被调用");
}

// 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类
@Override
public void method() {
System.out.println("Zi中method()方法被调用");
}

// 编译【出错】，父类的静态方法不能被重写
@Override
static public void method2() {
System.out.println("Zi中method2()方法被调用");
}
}
权限修饰符：public > protected > default > private

二、方法重写的规则

1、子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表；

2、子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型；

• 返回值是基本数据类型时，必须和父类的返回值类型相同；
• 返回值是引用数据类型时（类类型），子类重写方法返回的类型应该是父类被重写方法返回的类型或者其子类。（小于等于）

3、子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限；

• 注意：子类不能重写父类中声明为private权限的方法。

4、子类方法抛出的异常不能大于父类被重写方法的异常。

注意：子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。

下面对于这些规则进行详细的解读，让大家更容易理解。

1. 子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表。

确定性，如果不具备基本的方法名称和参数列表，就确定不了需要被重写方法的位置。

2. 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型。

因为多态，我们将子类向上转型为父类后，调用父类重写的方法，得到返回值，因为java是个强类型语言，所以编译期间要给返回值赋予类型。因为，编译期间的返回值类型（父类的）需要大于等于运行时期的返回值类型(子类的)。

// 父类
class SuperClass{
public People create(){
return new People();
}
}
// 子类
class SubClass extends SuperClass{
public Student create(){
return new Student();
}
}

class People{
}

class Student extends People{
}

public class OverrideTest {
public static void main(String[] args) {
SuperClass test = new SubClass();
//多态性，return new D()，故返回类型应该小于等于编译时类型（C类，父类中被重写的返回值类型）
People testC = test.create();
}
}

3.子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限。

因为在使用多态的时候经常把子类向上转型为父类，进而父类.方法(形参列表)。而“父类.方法(形参列表)”这个语句能够编译成功没有报错，说明该方法的权限修饰符是可以在调用该方法的语句块中执行的，所以如果子类的被重写的方法的权限修饰符是大于等于父类该方法的权限修饰符，那么多态时就一定可以调用子类重写的方法，也就是运行时权限修饰符要大于等于编译器权限修饰符，这样才能保证运行时满足权限。

// 父类
class SuperClass{
public void method(){
}
}
// 子类
class SubClass extends SuperClass{
//非法，子类中的method()的访问权限private比被覆盖方法的访问权限public小
private void method(){//error
}
}


public class OverrideTest {
public static void main(String[] args) {
SuperClass a = new SubClass();
a.method();//保证此时SubClass.method()是可以运行的
}
}

4.子类方法抛出的异常不能大于父类被重写方法的异常。

如果子类重写的方法抛出的异常更大，那么在多态的情况下， 父类的引用调用的方法只能看到小范围的异常，代码运行的时候，才知道具体是调用了那个子类对象的方法，如果此时子类对象的方法抛出的异常更大，从逻辑上来说，是错误的。

class A{//父类
public void method() throws IOException{
}
}
class B extends A{//子类
// 子类重写的方法抛出的异常类型小于等于父类被重写的方法抛出的异常类型
public void method() throws FileNotFoundException{
}
}

public class OverrideTest {
public static void main(String[] args) {
OverrideTest test = new OverrideTest();
test.display(new B());
}
public void display(A a){
try {
a.method();
} catch (IOException e) {
// SuperClass 抛出的异常是 IOException，处理 IOException 异常
// 如果子类抛出的异常更大，那么 父类就无法 catch 子类的异常。
// 所以禁止子类抛出的异常更大
e.printStackTrace();
}
}
}

方法重写是Java中非常重要的概念之一，它为我们提供了一种重新定义和修改父类已有方法的能力。通过理解方法重写的概念、原则和注意事项，并掌握其应用技巧，我们可以更好地应用它来实现类似继承的功能，并为我们的程序增加更高的灵活性和可扩展性。

因此，学习和掌握方法重写的知识和技能对于Java开发人员来说是非常重要的。希望本文能够帮助你更好地理解和应用方法重写，并在你的Java编程中发挥重要的作用。

我们下期再见！

END

文案编辑|云端学长

文案配图|云端学长

内容由：云端源想分享