Java-重写与重载“迷云”及实例分析

最新推荐文章于 2023-03-16 13:51:28 发布

_陈肆

最新推荐文章于 2023-03-16 13:51:28 发布

阅读量254

点赞数

分类专栏：软件构造文章标签： java intellij-idea 软件工程

本文链接：https://blog.csdn.net/weixin_51611639/article/details/125227849

版权

软件构造专栏收录该内容

9 篇文章 0 订阅

订阅专栏

前言

当我们刚刚学习重写和重载时，还觉得挺简单清晰的。但当遇到实际问题时，我们常常很难辨析实际调用的是哪个版本的变量 / 哪个版本的函数。今天我就借此篇博客总结一下相关问题和经验，希望大家阅读后能够有所收获。

一些前置的知识点

1. 继承与重写

（1）继承概念：

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

（2）重写概念：

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。

实际执行时调用哪种方法，在运行时决定！！

（3）重写规则：

参数列表必须完全与被重写方法的相同；
返回类型必须完全与被重写方法的返回类型相同；
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
父类的成员方法只能被它的子类重写。
声明为final的方法不能被重写。
声明为static的方法不能被重写，但是能够被再次声明。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
构造方法不能被重写。
如果不能继承一个方法，则不能重写这个方法。

（4）一些需要注意的点

【1】严格继承：子类只能添加新方法，而不能重写超类中的方法

——父类中的方法都用 final 修饰，不可重写

【2】super的使用：重写时可利用super()复用父类型中函数的功能，并对其进行了扩展
特殊：子类构造函数中如果想复用父类构造器的功能，必须在第一句调用super()
【否则报错：Call to 'super()' must be first statement in constructor body】

2. 多态与重载

（1）多态概念：

多态是同一行为具有多种不同表现形式或形态的能力
（2）三种类型的多态：

Ad hoc polymorphism (特殊多态)：功能重载，一个函数可以有多个同名的实现。
Parametric polymorphism (参数多态): 泛型或泛型编程，一个类型名字可以代表多个类型
Subtyping (also called subtype polymorphism or inclusion polymorphism 子类型多态、包含多态):当一个名称表示许多不同的类与一些常见的超类相关的实例。

（3）重载的概念：

        重载(overloading) 是在一个类里面，方法名字相同，而参数不同，返回类型可以相同也可以不同。
        每个重载的方法（或构造函数）都必须有一个独一无二的参数类型列表。
        价值：方便client调用，client可用不同的参数列表，调用同样的函数。
        重载是静态多态，根据参数列表进行最佳匹配。在编译阶段时决定要具体执行哪个方法 (static type checking) ，与之相反，重构方法则是在run-time进行dynamic checking！

（4）重载的规则：

被重载的方法必须改变参数列表(参数个数或类型不一样)；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。
无法以返回值类型作为重载函数的区分标准。

3. 对比

经验总结（重点！！）

1. 编译时

① 检查方法是否可以被调用（left→引用类型：比较引用类型对应的类中是否具有方法具有相同的方法名与参数列表）

② 确定多态重载的方法具体使用版本（参数匹配→类型检查：静态）

2. 运行时

确定重写的方法具体使用版本（right→对象类型）

代码范例

代码范例1

public class A
{
    public int i=1;
    public void move()
    {
        System.out.println("A methhod");
        i++;
        System.out.println("A: i="+i);
    }

    public static void main(String[] args) {
        A a = new B();
        System.out.println("i="+a.i);
        a.move();
        System.out.println("i="+a.i);
    }
}
class B extends A{
    public int i=2;

    //将讨论下边重写方法注释前后运行结果变化
    @Override
    public void move()
    {
        System.out.println("B methhod");
        i+=2;
        System.out.println("B: i="+i);
    }
}

（1）注释方法前

分析：

【1】 “ A a = new B() ”中，a的引用类型为A，决定了方法外“ a.i ”中的i使用的是A中的版本；

【2】 “ A a = new B() ”中，a的对象类型为B，决定了“ a.move() ”中调用的move()是B中的版本；故而方法中使用的i也是B中的版本，“ i+=2 ”的结果为4

【3】综合以上两点，方法内外使用的i是不同的版本，故而调用方法前后，打印i的结果不变

（2）注释方法后

分析：

B未重写A中的move()方法，故move方法只在A中，“ a.move() ”实际调用的是A中的move；故而方法中使用的i也是A中的版本，“ i+=1 ”的结果为2

代码范例2

public class A
{
    public void move()
    {
        System.out.println("A methhod:move()");
    }
    public static void main(String[] args) {
        String s = new String();
        Object o = new Object();
        A a = new B();
        a.move();
        //a.move(o);
        B b = new B();
        b.move(s);
    }
}
class B extends A{
    @Override
    public void move() {
        System.out.println("B methhod:move()");
    }
    /*public void move(String a) {
        System.out.println("B methhod:move(String a)");
    }*/
    public void move(Object b) {
        System.out.println("B methhod:move(Object b)");
    }
}

分析：

【1】 “ a.move(o) ”编译阶段报错：“ A a = new B() ”中，a的引用类型为A，静态检查时，A中并无对应的move(Object)