Carson带你学Java多态：深入解析方法重写（Override） & 方法重载（Overload）

Myth丶恋晨 2022-05-17 06:50 107阅读 0赞

![fedcf827170b012c679b233fbf30c8bb.png][]

# 前言 #

*  在`Java`中，作为三大特性之一的**多态** 十分重要，特别是其表现形式：方法重载（`Overload`）、方法重写（`Override`）
 *  本文全面 & 详细解析`Java`的多态特性，希望你们会喜欢

--------------------

# 目录 #

![示意图][732b51b77dd89946c20a0694d28863cd.png]

--------------------

# 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. 数据存储方式 ####

![示意图][920b36a43fa90da552f124b7ae0f4f80.png]

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

*  问：建立对象后，该如何访问对象呢？

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

*  答：`Java`程序 通过 栈上的引用类型数据（`reference`） 来访问`Java`堆上的对象

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

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

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

具体请看如下介绍：

![示意图][dc332fe8edbcac679a968ff618ed9f75.png]

--------------------

# 5. 类型 #

*  主要包括：编译时的多态性 & 运行时的多态性
 *  实现方式分别是：方法重载（`Overload`、前绑定）、方法重写（`Override`、后绑定）

下面，我将详细讲解方法重载（`Overload`） & 方法重写（`Override`）

--------------------

# 6. 方法重载（Overload） #

### 6.1 简介 ###

![示意图][9a772e83c6aaf4494c331b9d8da11544.png]

### 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` 虚拟机来执行

*  原理解析

--------------------

# 7. 方法重写（Override） #

### 7.1 简介 ###

![示意图][2e41b37e6de5cd8940556d304df6b939.png]

### 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 原理：动态分派 ###

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

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

*  原理解析

--------------------

# 8. 方法重载（Overload） & 方法重写（Override）对比 #

*  总结

![示意图][13509e94225d090b5962d16ee1b7b8b7.png]

*  对比 & 区别

![示意图][061ecece6e0c97920225e7138bdec6c3.png]

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

--------------------

# 9. 总结 #

*  本文主要讲解了`Java`中三大特性之一的**多态特性**，其中着重讲解其表现形式：方法重载（`Overload`）、方法重写（`Override`）
 *  下面我将继续对 `Android & Java`中的知识进行深入讲解 ，感兴趣的同学可以继续关注 [CSDN博客][CSDN] 与 微信公众号。  
    ![06b2ed0fbb8979f0aba34c14ede04b59.png][]

--------------------

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

[fedcf827170b012c679b233fbf30c8bb.png]: /images/20220517/b77d82c678a44f6e9d07a9aac690eaff.png
[732b51b77dd89946c20a0694d28863cd.png]: /images/20220517/7d59033141a04be0abb55d0c567c78d2.png
[920b36a43fa90da552f124b7ae0f4f80.png]: /images/20220517/68bdbb8c8e164a16bd49b77d62ff8219.png
[dc332fe8edbcac679a968ff618ed9f75.png]: /images/20220517/f49cd7cdbaae497cb76c6bf0ce3d7bc5.png
[9a772e83c6aaf4494c331b9d8da11544.png]: /images/20220517/22a849160cb04cb5b10359fe15ec2c0f.png
[2e41b37e6de5cd8940556d304df6b939.png]: /images/20220517/0b0cc8d97d1e40379907fc66831b9faf.png
[13509e94225d090b5962d16ee1b7b8b7.png]: /images/20220517/b9312a20768f43018c989adcd2781cfb.png
[061ecece6e0c97920225e7138bdec6c3.png]: /images/20220517/6057a66004154ec0a1059d9ef5c01cbc.png
[CSDN]: https://carsonho.blog.csdn.net/
[06b2ed0fbb8979f0aba34c14ede04b59.png]: /images/20220517/0b883a789d3a496b94c3c9d26cd92aad.png