青麦丨Java 多态
java多态讲解
java多态讲解一、多态的表现形式多态的表现形式有方法重载，方法改写，多态变量和泛型。
重载是一种静态的多态性，在程序编译时确定被调用的方法，称为早绑定。
而多态变量和改写相结合之后，方法的调用在运行时才能确定，是动态的多态性，称为晚绑定。
二、里氏替换原则（The Liskov Principle of Substitution）在静态类型语言中，父类和子类之间的关系存在下面的现象：子类的实例必须拥有父类的所有数据成员；子类的实例必须至少通过继承（如果不是显示地改写）实现父类所定义的所有功能。
这样，在某种条件下，如果用子类实例来替换父类实例，那么将会发现子类实例可以完全模拟父类的行为，二者毫无差别。
替换原则是指如果有A和B两个类，类B是类A的子类，那么在任何情况下都可以用类B来替换类A，而外界则毫无察觉。
不是所有继承产生的子类都符合替换原则，符合替换原则的子类称为子类型。
三、静态类型和动态类型在静态类型面向对象语言中，一个变量所存储的值的类型并不等同于这个变量所声明的类型。
声明为父类类型的变量可以包含子类的实例值。
静态类型是指变量在声明时所确定的类型，并且一经声明就不会改变；动态类型是指这个变量实际存储的值的类型。
在静态类型的面向对象程序设计语言中，在编译时消息传递表达式的合法性不是基于接收器的动态类型，而是基于接收器的静态类型。
而对象对消息的响应取决于对象的动态类型。
就是说，写代码的时候“点”不出该对象动态类型包含而静态类型不包含的变量、方法；动态类型就是程序运行过程中被重新赋值为对其他对象的引用，这时候他就可以含有动态类型对象的方法了。
这样的变量在多态中称为多态变量。
考虑下面的类图：对应的程序如下：class SuperClass {public int x;public void f1() {}public void f2() {}}class SubClass extends SuperClass{public int y;public void f1() {}public void f3() {}}public class Test{public static void main(String[] args){SuperClass ob=new SuperClass(); //(1)ob=new SubClass(); //(2)ob.x=1; //(3)ob.y=2; //(4)ob.f1(); //(5)ob.f2(); //(6)ob.f3(); //(7)}}程序中，子类改写了父类中的f1()方法，添加了自己的属性y和方法f3()。
Java多态详解
Java多态详解 多态是⾯向对象程序设计三⼤特征之⼀，所谓多态就是指程序中定义的引⽤变量所指向的具体类型和通过该引⽤变量发出的⽅法调⽤在编程时并不确定，⽽是在程序运⾏期间才确定，即⼀个引⽤变量倒底会指向哪个类的实例对象，该引⽤变量发出的⽅法调⽤到底是哪个类中实现的⽅法，必须在由程序运⾏期间才能决定。
因为在程序运⾏时才确定具体的类，这样，不⽤修改源程序代码，就可以让引⽤变量绑定到各种不同的类实现上，从⽽导致该引⽤调⽤的具体⽅法随之改变，即不修改程序代码就可以改变程序运⾏时所绑定的具体代码，让程序可以选择多个运⾏状态，这就是多态性。
1、向上转型要理解多态就必须理解向上转型，考虑以下例⼦，shape1和shape2是Shape类型，分别赋值的为Shape的两个⼦类Circle和Rectangle的实例，这说明Circle和Rectangle是可以转型为Shape类型，所以shape可以指向Circle和Rectangle的实例，这就是向上转型。
1public class Shape{2void draw(){}3 }45public class Rectangle extends Shape {6void draw() {7 System.out.println("draw Rectange");8 }9 }1011public class Circle extends Shape {12void draw() {13 System.out.println("draw circle");14 }15 }1617public class Test {18public static void main(String []args) {19 Shape shape1 = new Circle();20 Shape shape2 = new Rectangle();2122 shape1.draw();23 shape2.draw();24 }25 } out: draw circle draw Rectange2、动态绑定 上⾯的例⼦中，shape1和shape2调⽤draw，可以从输出看出，实际调⽤的是⼦类的draw，⽽不是shape1和shape2本⾝的类型Shape 的draw，这是为什么呢？这⾥必须要知道函数绑定的概念，将⼀个函数调⽤与函数主题连接在⼀起就叫做函数绑定（binding），若在程序运⾏之前执⾏绑定(编译阶段和链接阶段)，叫做早期绑定，⽐如熟悉的C语⾔；若在程序运⾏时执⾏绑定，就叫做动态绑定（后期绑定），这样即可以在运⾏时确定对象的类型，并正确调⽤相应的函数，不同的语⾔对于动态绑定的实现时不⼀样的，java中的绑定采⽤的都是动态绑定（final函数除外，final⽅法不能被继承）。
Java基本概念：多态
Java基本概念：多态⼀、简介描述：多态性是⾯向对象编程中的⼀个重要特性，主要是⽤来实现动态联编的。
换句话说，就是程序的最终状态只有在执⾏过程中才被决定，⽽⾮在编译期间就决定了。
这对于⼤型系统来说能提⾼系统的灵活性和扩展性。
多态允许相同类域的不同对象对同⼀消息做出响应。
即同⼀消息可以根据发送对象的不同⽽采⽤多种不同的⾏为⽅式。
多态可以让我们不⽤关⼼某个对象到底是什么具体类型，就可以使⽤该对象的某些⽅法，从⽽实现更加灵活的编程，提⾼系统的可扩展性。
如果对象的编译时类型和运⾏时类型不⼀致，就会造成多态。
存在条件：1. 类之间有继承关系。
2. ⼦类重写⽗类⽅法。
3. ⽗类引⽤指向⼦类对象。
注意：多态是⽅法的多态，属性没有多态性。
⼀个对象的实际类型是确定的，但是可以指向这个对象的引⽤的类型，却是可以是这对象实际类型的任意⽗类型。
⼦类继承⽗类，调⽤⽅法，如果该⽅法在⼦类中没有重写，那么就是调⽤的是⼦类继承⽗类的⽅法，如果重写了，那么调⽤的就是重写之后的⽅法。
'protected'修饰的⽗类⽅法可以被⼦类见到，也可以被⼦类重写，但是它是⽆法被外部所引⽤的，所以没有多态性。
通过⼀个变量调⽤其引⽤的对象的⼀个⽅法，编译器是否能让其编译通过，主要是看该变量类型的类中有没有定义该⽅法，如果有则编译通过，如果没有则编译报错。
⽽不是看这个变量所引⽤的对象中有没有该⽅法。
Java中的⽅法调⽤，是运⾏时动态和对象绑定的，不到运⾏的时候，是不知道到底哪个⽅法被调⽤的。
编写程序时，如果想调⽤运⾏时类型的⽅法，只能进⾏类型转换，不然通不过编译器的检查。
但是如果两个没有关联的类进⾏强制转换，会报类型转换异常：ClassCastException。
⽰例：public class Test {public static void main(String[] args) {/* 编译看左，运⾏看右 */Student student = new Student();/* 变量person是可以指向Person类型或其⼦类型的对象，所以可以指向Student类型对象 */Person person = new Student();/* 变量student能调⽤的⽅法是Student类中有的⽅法(包括继承过来的) */student.say();//Student/* 变量person能调⽤的⽅法是Person类中有的⽅法 */person.say();//Student}}class Person {public void say() {System.out.println("Person");}}class Student extends Person {public void say() {System.out.println("Student");}}⼆、重写、重载、多态的关系1. 重载是编译时多态调⽤重载的⽅法，在编译期间就要确定调⽤的⽅法是谁，如果不能确定则编译报错。
在JAVA中有两种多态指的是什么
同问 在JAVA中有两种多态指的是什么 2009-01-15 14:32 提问者： mdydyy |浏览次数：2218次
我来帮他解答
精彩回答
2009-01-15 15:11在JAVA中有两种多态是指：运行时多态和编译时多态。关于类的多态性简介如下： 多态(polymorphism)意为一个名字可具有多种语义.在程序设计语言中,多态性是指”一种定义,多种实现”.例如,运算符+有多种含义,究竟执行哪种运算取决于参加运算的操作数类型: 1+2 //加法运算符 “1” + “2” //字符串连接运算,操作数是字符串 多态性是面向对象的核心特征之一,类的多态性提供类中成员设计的灵活性和方法执行的多样性. 1、类多态性表现 (1)方法重载 重载表现为同一个类中方法的多态性.一个类生命多个重载方法就是为一种功能提供多种实现.编译时,根据方法实际参数的数据类型\个数和次序,决定究竟应该执行重载方法中的哪一个. (2)子类重定义从父类继承来的成员 当子类从父类继承来的成员不适合子类时,子类不能删除它们,但可以重定义它们,使弗雷成员适应子类的新需求.子类重定义父类成员,同名成员在父类与子类之间表现出多态性,父类对象引用父类成员,子类对象引用子类成员,不会产生冲突和混乱. 子类可重定义父类的同名成员变量,称子类隐藏父类成员变量.子类也可以重定义父类的同名成员方法，当子类方法的参数列表与父类方法参数列表完全相同时，称为子类方法覆盖（override）父类方法。覆盖父类方法时，子类方法的访问权限不能小于父类方法的权限。 由于Object类的equals()方法比较两个对象的引用是否相等而不是值是否相等,因此一个类要覆盖Object类的equals()方法,提供本类两个对象比较相等方法. 覆盖表现为父类与子类之间方法的多态性.java 寻找执行方法的原则是:从对象所属的类开始,寻找匹配的方法执行,如果当前类中没有匹配的方法,则逐层向上依次在父类或祖先类中寻找匹配方法,直到Object类. 2、super 引用 在子类的成员方法中,可以使用代词super引用父类成员.super引用的语法如下: super([参数列表]) //在子类的构造方法体中,调用父类的构造方法 super.成员变量 //当子类隐藏父类成员变量时,引用父类同名成员变量 super.成员方法([参数列表]) //当子类覆盖父类成员方法时,调用父类同名成员方法 *注意:super引用没有单独使用的语法 3、多态性有两种: 1）编译时多态性 对于多个同名方法,如果在编译时能够确定执行同名方法中的哪一个,则称为编译时多态性. 2）运行时多态性 如果在编译时不能确定,只能在运行时才能确定执行多个同名方法中的哪一个,则称为运行时多态性. 方法覆盖表现出两种多态性,当对象获得本类实例时,为编译时多态性,否则为运行时多态性,例如: XXXX x1 = new XXXX(参数列表); //对象获得本类实例,对象与其引用的实例类型一致 XXX xx1 = new XXX(参数列表); x1.toString(); //编译时多态性,执行XXX类的方法. xx1.toString(); //编译时多态性,执行XXXX类覆盖的方法. XXXX为XXX的父类. 由于子类对象既是父类对象,父类对象与子类对象之间具有赋值相容性,父类对象能够被赋值为子类对象.例如, XXXX x2 = new XXX(参数列表); //父类对象获得子类实例,子类对象即是父类对象 x2.toString(); //运行时多态 x2声明为父类对象却获得子类XXX的实例,那么x2.toString()究竟执行父类方法还是执行子类覆盖的方法呢? 这分为两种情况: 取决于子类是否覆盖父类方法.如果子类覆盖父类方法,则执行子类方法; 如果没有覆盖,则执行父类方法. 在编译时,仅仅依据对象所属的类,系统无法确定到底应该执行那个类的方法,只有运行时才能确定,因此这是运行时多态. 父类对象并不能执行所有的子类方法,只能执行那些父类中声明\子类覆盖的子类方法.
JAVA多态性 ppt课件
a.fun1();
// 此方法被子类覆写过
}
}
PPT课件
6
对象的向下转型
class A{ public void fun1(){
// 定义类A // 定义fun1()方法
System.out.println("A --> public void fun1(){}") ;
} public void fun2(){
PPT课件
5
对象的向上转型
class A{ public void fun1(){
// 定义类A // 定义fun1()方法
System.out.println("A --> public void fun1(){}") ;
} public void fun2(){
// 定义fun2()方法
this.fun1() ;
A a = new B() ;
// 发生了向上转型的关系，子类 --> 父类
B b = (B)a ;
// 此时发生了向下转型关系
b.fun1() ;
// 调用方法被覆写的方法
b.fun2() ;
// 调用父类的方法
b.fun3() ;
// 调用子类自己定义的方法
}
}
PPT课件
7
多态禁忌
•千万不要出现这样的操作:就是将父类对象转换成为子类是类型 – Animal a=new Animal(); – Dog d4=(Dog)a;//类造型异常
}
}; class B extends A{
public void fun1(){
// 子类通过extends继承父类 // 覆写父类中的fun1()方法
《java面向对象程序设计继承和多态》教案
《Java面向对象程序设计-继承和多态》教案第一章：引言1.1 课程简介本课程旨在帮助学生掌握Java面向对象程序设计中的继承和多态概念。
通过学习，学生将能够理解继承和多态的原理，并能够运用它们解决实际编程问题。
1.2 课程目标理解继承的概念和原理掌握如何使用继承来实现代码复用理解多态的概念和原理掌握如何使用多态来实现动态绑定第二章：继承2.1 继承的概念介绍继承的定义和作用解释为什么使用继承2.2 继承的语法介绍如何使用extends关键字实现继承解释继承中的构造函数和继承关系2.3 继承的实现演示如何使用继承来复用代码解释继承的层次结构和菱形继承第三章：多态3.1 多态的概念介绍多态的定义和作用解释多态的好处3.2 方法重写解释方法重写的概念和规则演示如何使用方法重写来实现多态3.3 方法重载解释方法重载的概念和规则演示如何使用方法重载来提高代码可读性第四章：继承和多态的案例分析4.1 案例一：动物和鸟类使用继承和多态来定义动物和鸟类的关系实现动物和鸟类的属性和方法4.2 案例二：形状和圆形使用继承和多态来定义形状和圆形的关系实现形状和圆形的属性和方法第五章：总结和练习5.1 课程总结回顾继承和多态的概念和原理强调继承和多态在面向对象程序设计中的重要性5.2 练习题提供一些练习题，以帮助学生巩固所学知识第六章：继承和多态的深入理解6.1 继承的类型解释接口继承和类继承的区别讨论继承的优点和缺点6.2 多态的应用探讨多态在日常编程中的应用场景分析多态如何提高程序的可扩展性和灵活性第七章：Java中的继承和多态实例7.1 继承实例：汽车和摩托车通过实例展示如何使用继承来创建汽车和摩托车类演示如何通过继承来扩展属性和方法7.2 多态实例：支付接口和具体的支付方式创建一个支付接口和多个具体的支付方式类演示如何使用多态来实现不同的支付方法第八章：继承和多态的陷阱与最佳实践8.1 继承的陷阱讨论继承可能带来的过度耦合问题解释如何避免继承的陷阱8.2 多态的陷阱分析多态可能导致的类型不匹配问题探讨如何安全地使用多态8.3 最佳实践提供使用继承和多态的最佳实践指南强调代码可读性和可维护性第九章：继承和多态在设计模式中的应用9.1 设计模式简介介绍设计模式的概念和重要性解释设计模式与继承和多态的关系9.2 继承和多态在设计模式中的应用案例通过案例分析展示继承和多态如何在设计模式中发挥作用讨论设计模式如何提高程序设计的质量和可复用性第十章：课程回顾与拓展学习10.1 课程回顾总结本课程的重点内容和关键概念强调继承和多态在实际编程中的应用10.2 拓展学习资源提供一些拓展学习的资源和建议鼓励学生继续深入学习面向对象程序设计的其他方面第十一章：继承和多态的实际应用案例11.1 案例分析：图形库的设计通过分析图形库的设计，展示继承和多态如何用于实现复杂的图形操作。
Java程序设计教程第7章7.2 多 态
master.feed(xxx); ……
public void feed( XXX xxx ) { xxx.eat();
可否使用一个feed(Pet pet) 实现对所有宠物的喂食？
}
… … 频繁修改代码，代码可扩展性、可维护性差，
}
如何优化？
课堂操作——购置新车2-2
提前做完的同学可以尝试改进系统：
1. 循环从控制台选择汽车种类 2. 从控制台输入天数 3. 累加计算总租金
20/30
多态
总结
使用多态的好处
减少类中代码量 提高代码的可扩展性和可维护性
向上转型——子类转换为父类，自动进行类型转换
向下转型——父类转换为子类，结合instanceof运算符进行强 制类型转换
编写测试方法
调用主人类给狗狗喂的方法 调用主人类给企鹅喂的方法
为什么使用多态5-2
3/30
为什么使用多态5-3
问题
如果再领养XXX宠物，并需要给XXX喂食，怎么办？
添加XXX类，继承Pet类，实现吃食方法 修改Master类，添加给XXX喂食的方法
4/30
为什么使用多态5-4
主人类
练习
需求说明
使用多态实现喂养宠物功能 增加宠物猫并喂食，其健康值增加4
9/30
使用父类作为方法返回值实现多态
使用多态实现领养宠物
使用父类作为方法返回值 实现思路
在Master类添加领养方法getPet(String typeId ) 创建测试类，根据主人选择宠物类型编号来领养宠物
public class Master { public void feed( Dog dog ) { dog.eat(); } public void feed( Penguin pgn ) { pgn.eat(); }
Java基础知识总结(超详细整理)
Java基础知识总结（超详细整理）Java语⾔的特点1.⾯向对象⾯向对象(OOP)就是Java语⾔的基础，也是Java语⾔的重要特性。
⾯向对象的概念：⽣活中的⼀切事物都可以被称之为对象，⽣活中随处可见的事物就是⼀个对象，我们可以将这些事物的状态特征（属性）以及⾏为特征（⽅法）提取并出来，并以固定的形式表⽰。
2.简单好⽤Java语⾔是由C和C++演变⽽来的，它省略了C语⾔中所有的难以理解、容易混淆的特性（⽐如指针），变得更加严谨、简洁、易使⽤。
3.健壮性Java的安全检查机制，将许多程序中的错误扼杀在摇蓝之中。
另外，在Java语⾔中还具备了许多保证程序稳定、健壮的特性（强类型机制、异常处理、垃圾的⾃动收集等），有效地减少了错误，使得Java应⽤程序更加健壮。
4.安全性Java通常被⽤在⽹络环境中，为此，Java提供了⼀个安全机制以防恶意代码的攻击，从⽽可以提⾼系统的安全性。
5.平台⽆关性Java平台⽆关性由Java 虚拟机实现，Java软件可以不受计算机硬件和操作系统的约束⽽在任意计算机环境下正常运⾏。
6.⽀持多线程在C++ 语⾔没有内置的多线程机制，因此必须调⽤操作系统的多线程功能来进⾏多线程程序设计，⽽ Java 语⾔却提供了多线程⽀持。
多线程机制使应⽤程序在同⼀时间并⾏执⾏多项任务，该机制使得程序能够具有更好的交互性、实时性。
7.分布式（⽀持⽹络编程）Java语⾔具有强⼤的、易于使⽤的⽹络能⼒，⾮常适合开发分布式计算的程序。
java中提供了⽹络应⽤编程接⼝()，使得我们可以通过URL、Socket等远程访问对象。
8.编译与解释共存Java语法基础标识符： ⽤来标识类名、对象名、变量名、⽅法名、类型名、数组名、⽂件名的有效字符序列。
合法的标识符：由字母、数字、下划线“_”、美元符号“$”或者“￥”组成，并且⾸字符不能是数字。
不能把java关键字和保留字作为标识符。
标识符对⼤⼩写敏感。
关键字：Java语⾔中已经赋予了特定含义的保留字： const、goto，Java版本中尚未使⽤，但以后版本可能会作为关键字使⽤变量：程序运⾏期间可以被改变的量。
java多态实现原理
java多态实现原理Java多态实现什么是多态多态是面向对象程序设计中的一种重要特性，它允许使用父类型的引用来引用子类型的对象，从而实现了不同对象的统一处理。
多态的实现原理在Java中，多态是通过继承和重写来实现的。
下面我们将结合具体的例子来一步步解释多态的实现原理。
假设有一个父类Animal和两个子类Dog和Cat，它们都有一个共同的方法makeSound：class Animal {public void makeSound() {("Animal makes sound");}}class Dog extends Animal {@Overridepublic void makeSound() {("Dog barks");}}class Cat extends Animal {@Overridepublic void makeSound() {("Cat meows");}}现在我们可以创建一个Animal类型的引用变量，通过这个引用变量来引用不同子类的对象。
Animal animal;animal = new Dog();(); // 输出："Dog barks"animal = new Cat();(); // 输出："Cat meows"在上面的代码中，animal是Animal类型的引用变量，它可以引用Dog和Cat这两个子类的对象。
当我们调用makeSound方法时，会执行子类的重写方法，输出子类特有的声音。
多态的好处多态的引入使得代码更加灵活和可扩展。
通过父类型的引用来引用子类型的对象，我们可以在不改变原有代码的情况下添加新的子类，从而实现了代码的可扩展性。
多态的应用场景多态在实际的程序设计中得到了广泛应用，特别是在面向对象的程序设计中。
下面列举几个常见的多态的应用场景：•抽象数据类型的实现，如链表、栈和队列等；•接口的使用，实现了接口的类可以通过接口类型的引用来引用；•方法的参数和返回值类型可以使用父类型，从而支持多态传递。
Java中封装、继承、多态的理解
Java中封装、继承、多态的理解Java中的继承、封装、多态继承的理解：1、继承是⾯向对象的三⼤特征之⼀，也是实现代码复⽤的重要⼿段。
Java的继承具有单继承的特点，每个⼦类只有⼀个直接⽗类。
2、Java的继承通过extends关键字来实现，实现继承的类被称为⼦类，被继承的类称为⽗类(有的也称其为基类、超类)，⽗类和⼦类的关系，是⼀种⼀般和特殊的关系。
就像是⽔果和苹果的关系，苹果继承了⽔果，苹果是⽔果的⼦类，⽔果是苹果的⽗类，则苹果是⼀种特殊的⽔果。
3、Java使⽤extends作为继承的关键字，extends关键字在英⽂是扩展的意思，⽽不是继承。
为什么国内把extends翻译成继承呢？除了与历史原因有关外，把extends翻译成为继承也是有其道理的：⼦类扩展⽗类，将可以获得⽗类的全部属性和⽅法，这与汉语中得继承（⼦辈从⽗辈那⾥获得⼀笔财富成为继承）具有很好的类似性。
值得指出的是：Java的⼦类不能获得⽗类的构造器。
4、实例：class BaseClass{public double weight;public void info() {System.out.println("我的体重是"+weight+"千克");}}public class ExtendsDemo001 extends BaseClass {public static void main(String[] args) {//创建ExtendsDemo001对象ExtendsDemo001 ed = new ExtendsDemo001();//ExtendsDemo001本⾝没有weight属性，但是ExtendsDemo001的⽗类有weight属性，也可以访问ExtendsDemo001对象的属性ed.weight = 56;//调⽤ExtendsDemo001对象的info()⽅法();}}打印结果为：我的体重是56.0千克5、Java类只能有⼀个⽗类。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
青麦丨Java 多态
多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：
多态性是对象多种表现形式的体现。
现实中，比如我们按下F1 键这个动作：
∙如果当前在Flash 界面下弹出的就是AS 3 的帮助文档；
∙如果当前在Word 下弹出的就是Word 帮助；
∙在Windows 下弹出的就是Windows 帮助和支持。
同一个事件发生在不同的对象上会产生不同的结果。
多态的优点
∙ 1. 消除类型之间的耦合关系
∙ 2. 可替换性
∙ 3. 可扩充性
∙ 4. 接口性
∙ 5. 灵活性
∙ 6. 简化性
多态存在的三个必要条件
∙继承
∙重写
∙父类引用指向子类对象
比如：
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。
以下是一个多态实例的演示，详细说明请看注释：
Test.java 文件代码：
虚方法
我们将介绍在Java中，当设计类时，被重写的方法的行为怎样影响多态性。
我们已经讨论了方法的重写，也就是子类能够重写父类的方法。
当子类对象调用重写的方法时，调用的是子类的方法，而不是父类中被重写的方法。
要想调用父类中被重写的方法，则必须使用关键字super。
Employee.java 文件代码：
Salary.java 文件代码：
VirtualDemo.java 文件代码：
例子解析
∙
实例中，实例化了两个Salary 对象：一个使用Salary 引用s，另一个使用Employee 引用e。
∙
∙
当调用s.mailCheck() 时，编译器在编译时发现mailCheck() 在Salary 类中，执行过程JVM 就调用Salary 类的mailCheck()。
∙
∙
在调用s.mailCheck()时，Java虚拟机(JVM)调用Salary类的mailCheck()方法。
∙
∙
因为e 是Employee 的引用，所以调用e 的mailCheck() 方法时，编译器会去Employee 类查找mailCheck() 方法。
∙
∙
在编译的时候，编译器使用Employee 类中的mailCheck() 方法验证该语句，但是在运行的时候，Java 虚拟机(JVM)调用的是Salary 类中的mailCheck()方法。
∙
以上整个过程被称为虚拟方法调用，该方法被称为虚拟方法。
Java中所有的方法都能以这种方式表现，因此，重写的方法能在运行时调用，不管编译的时候源代码中引用变量是什么数据类型。
多态的实现方式
方式一：重写：
这个内容已经在上一章节详细讲过，就不再阐述，详细可访问：Java 重写(Override)与重载(Overload)。
方式二：接口
∙
1. 生活中的接口最具代表性的就是插座，例如一个三接头的插头都能接在三孔插座中，因为这个是每个国家都有各自规定的接口规则，有可能到国外就不行，那是因为国外自己定义的接口类型。
∙
∙。