前言

• 在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栈中的本地变量表

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

2. 根据地址，从而找到方法区中的对象类型数据（B的对象类型数据）
3. 查询 对象类型数据中的方法表 定位到 实际类（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 hellowoman 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 hellowoman say hello// 起因解析// 1. 方法重写（Override） = 动态分派 = 根据 变量的动态类型 确定执行（重写）哪个方法// 2. 对于情况1：根据变量（Man）的动态类型（man）确定调用man中的重写方法sayHello()// 3. 对于情况2：根据变量（Man）的动态类型（woman）确定调用woman中的重写方法sayHello()

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

• 总结

示用意

• 比照 & 区别

示用意

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

9. 总结

本文主要讲解了Java中三大特性之一的多态特性，其中着重讲解其体现形式：方法重载（Overload）、方法重写（Override）

欢迎关注Carson_Ho的简书！

分享Android技术干货，追求短、平、快，但却不缺深度。

请点赞！由于你的鼓励是我写作的最大动力！

相关文章阅读
Android开发：最全面、最易懂的Android屏幕适配处理方案
Android事件分发机制详解：史上最全面、最易懂
Android开发：史上最全的Android消息推送处理方案
Android开发：最全面、最易懂的Webview详解
Android开发：JSON简介及最全面解析方法!
Android四大组件：Service服务史上最全面解析
Android四大组件：BroadcastReceiver史上最全面解析