Java 多态:深入解析方法重写(Override) & 方法重载(Overload)

版权声明:本文为博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://carsonho.blog.csdn.net/article/details/81502540

前言

  • Java中,作为三大特性之一的多态 十分重要,特别是其表现形式:方法重载(Overload)、方法重写(Override
  • 本文全面 & 详细解析Java的多态特性,希望你们会喜欢

目录

示意图


1. 定义

对于同1个类型的不同实例对象,同一个行为 具备不同的表现形式


2. 作用

a. 消除同一类型之间的耦合关系
b. 使得不同对象 对于同一行为 具备多种表现形式

如 对于“恐龙”这个类,其具体对象可以是“飞龙” & “暴龙”,对于同1个“吼叫”行为,吼出的声音则不同。


3. 原理

3.1 知识储备:变量的静态类型 & 动态类型

  • 变量的静态类型 = 引用类型 = 编译时变量 :不会被改变、在编译器可知
  • 变量的动态类型 = 实例对象类型 = 运行时变量 :会变化、在运行期才可知

请看如下示例:

public class Test { 
    // Human是 Man与Human的父类
    static abstract class Human { 
    } 
 
    static class Man extends Human { 
    } 
 
    static class Woman extends Human { 
    } 

// 执行代码
public static void main(String[] args) { 

  Human man = new Man(); 
  // 变量man的静态类型 = 引用类型 = 编译时变量 = Human:不会被改变、在编译器可知
  // 变量man的动态类型 = 实例对象类型 = 运行时变量 = Man :会变化、在运行期才可知

    } 
}

3.2 实现原理

通过将 子类对象实例 赋值给 父类引用变量使得编译时的静态变量 与 运行时的动态变量不一样,在调用方法 / 变量时,多态就发生了。

3.3 应用示例

// 设 B类是A类的子类

A b = new B();  //编译时变量 = A b 、运行时变量 = new B()
b.name;  // 调用了父类A的成员变量name 
b.move();  // 调用的是子类B重写后的2个方法move()、content()
b.content(); 

// 结论:因将 子类对象引用 赋值给 父类对象变量,即A a = new B(),即 编译时变量和运行时变量不一样,所以多态发生

4 实现过程(直接指针 访问)

  1. JVM 虚拟机通过 引用类型(reference,即A的引用)查询Java栈中的本地变量表

得到堆中的对象类型数据的地址

  1. 根据地址,从而找到方法区中的对象类型数据(B的对象类型数据)
  2. 查询 对象类型数据中的方法表 定位到 实际类(B类)的方法,从而运行

注:基础知识补充

  • 要充分了解多态的实现过程,还需了解以下JVM的基础知识
  • 对于:A a = new B()

a. 数据存储方式

示意图

b. 引用类型访问实现方式

  • 问:建立对象后,该如何访问对象呢?

实际上需要访问的是 对象实例数据 & 对象类型数据

  • 答:Java程序 通过 栈上的引用类型数据(reference) 来访问Java堆上的对象

由于引用类型数据(reference)在 Java虚拟机中只规定了一个指向对象的引用,但没定义该引用应该通过何种方式去定位、访问堆中的对象的具体位置

所以对象访问方式 取决于 虚拟机实现。目前主流的对象访问方式有两种:

  • 句柄 访问
  • 直接指针 访问

具体请看如下介绍:

示意图


5. 类型

  • 主要包括:编译时的多态性 & 运行时的多态性
  • 实现方式分别是:方法重载(Overload、前绑定)、方法重写(Override、后绑定)

下面,我将详细讲解方法重载(Overload) & 方法重写(Override


6. 方法重载(Overload)

6.1 简介

示意图

6.2 具体使用

public class Test { 

// 类定义
    static abstract class Human { 
    } 
 
// 继承自抽象类Human
    static class Man extends Human { 
    } 
 
    static class Woman extends Human { 
    } 
 
// 定义的重载方法(方法名相同,但参数列表不同(此处是类型不同))
    public void sayHello(Human guy) { 
        System.out.println("hello,guy!"); 
    } 
 
    public void sayHello(Man guy) { 
        System.out.println("hello gentleman!"); 
    } 
 
    public void sayHello(Woman guy) { 
        System.out.println("hello lady!"); 
    } 

// 测试代码
    public static void main(String[] args) { 
        Human man = new Man(); 
        Man woman = new Woman(); 
        Test test = new Test(); 

        test.sayHello(man); 
        test.sayHello(woman); 
    } 
}

// 运行结果
hello,guy! 
hello gentleman!

6.3 原理:静态分派

  • 定义
    根据 变量的静态类型 进行方法分派 的 行为
  1. 即根据 变量的静态类型 确定执行哪个方法
  2. 发生在编译期,所以不由 Java 虚拟机来执行
  • 原理解析
public class Test { 

// 类定义
    static abstract class Human { 
    } 
 
// 继承自抽象类Human
    static class Man extends Human { 
    } 
 
    static class Woman extends Human { 
    } 
 
// 定义的重载方法(方法名相同,但参数列表不同(此处是类型不同))
    public void sayHello(Human guy) { 
        System.out.println("hello,guy!"); 
    } 
 
    public void sayHello(Man guy) { 
        System.out.println("hello gentleman!"); 
    } 
 
    public void sayHello(Woman guy) { 
        System.out.println("hello lady!"); 
    } 

// 测试代码
    public static void main(String[] args) { 
        Human man = new Man(); 
        Man woman = new Woman(); 
        Test test = new Test(); 

        test.sayHello(man); 
        test.sayHello(woman); 
    } 
}

// 运行结果
hello,guy! 
hello gentleman!

// 原理解析
// a. 方法重载(OverLoad)的原理 = 静态分派 = 根据 变量的静态类型 确定执行(重载)哪个方法
// b. 所以上述的方法执行时,是根据变量(man、woman)的静态类型(Human、Man)确定重载sayHello()中参数为Human guy、Man guy的方法
// c. 即sayHello(Human guy)、sayHello(Man guy) 

7. 方法重写(Override)

7.1 简介

示意图

7.2 具体使用

// 定义类
    class Human { 
        public void sayHello(){ 
            System.out.println("Human say hello"); 
 
        } 
    } 
 
// 继承类Human 并 重写sayHello()
    class Man extends Human { 
        @Override 
        protected void sayHello() { 
            System.out.println("man say hello"); 
 
        } 
    } 
 
    class Woman extends Human { 
        @Override 
        protected void sayHello() { 
            System.out.println("woman say hello"); 
 
        } 
    } 

// 测试代码
    public static void main(String[] args) { 

        // 情况1
        Human man = new man(); 
        man.sayHello(); 

        // 情况2
        man = new Woman(); 
        man.sayHello(); 
    } 
}

// 运行结果
man say hello
woman say hello

// 原因解析
// 通过多态,调用了子类中复写的sayHello()

7.3 原理:动态分派

  • 定义
    根据 变量的动态类型 进行方法分派 的 行为

即根据 变量的动态类型 确定执行哪个方法

  • 原理解析
// 定义类
    class Human { 
        public void sayHello(){ 
            System.out.println("Human say hello"); 
 
        } 
    } 
 
// 继承类Human 并 重写sayHello()
    class Man extends Human { 
        @Override 
        protected void sayHello() { 
            System.out.println("man say hello"); 
 
        } 
    } 
 
    class Woman extends Human { 
        @Override 
        protected void sayHello() { 
            System.out.println("woman say hello"); 
 
        } 
    } 

// 测试代码
    public static void main(String[] args) { 

        // 情况1
        Human man = new man(); 
        man.sayHello(); 

        // 情况2
        man = new Woman(); 
        man.sayHello(); 
    } 
}

// 运行结果
man say hello
woman say hello

// 原因解析
// 1. 方法重写(Override) = 动态分派 = 根据 变量的动态类型 确定执行(重写)哪个方法
// 2. 对于情况1:根据变量(Man)的动态类型(man)确定调用man中的重写方法sayHello()
// 3. 对于情况2:根据变量(Man)的动态类型(woman)确定调用woman中的重写方法sayHello()


8. 方法重载(Overload) & 方法重写(Override)对比

  • 总结

示意图

  • 对比 & 区别

示意图

至此,关于Java中的多态特性讲解完毕。


9. 总结

  • 本文主要讲解了Java中三大特性之一的多态特性,其中着重讲解其表现形式:方法重载(Overload)、方法重写(Override

  • 下面我将继续对 Android & Java中的知识进行深入讲解 ,感兴趣的同学可以继续关注carson_ho的微信公众号
    示意图
    示意图


请帮顶 / 评论点赞!因为你的鼓励是我写作的最大动力!

展开阅读全文

没有更多推荐了,返回首页