Java
中,作为三大特性之一的多态 十分重要,特别是其表现形式:方法重载(Overload
)、方法重写(Override
) Java
的多态特性,希望你们会喜欢对于同1个类型的不同实例对象,同一个行为 具备不同的表现形式
a. 消除同一类型之间的耦合关系 b. 使得不同对象 对于同一行为 具备多种表现形式
如 对于“恐龙”这个类,其具体对象可以是“飞龙” & “暴龙”,对于同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 :会变化、在运行期才可知
}
}
通过将 子类对象实例 赋值给 父类引用变量,使得编译时的静态变量 与 运行时的动态变量不一样,在调用方法 / 变量时,多态就发生了。
// 设 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(),即 编译时变量和运行时变量不一样,所以多态发生
JVM
虚拟机通过 引用类型(reference
,即A的引用)查询Java
栈中的本地变量表
得到堆中的对象类型数据的地址 根据地址,从而找到方法区中的对象类型数据(
B
的对象类型数据) 查询 对象类型数据中的方法表 定位到 实际类(B
类)的方法,从而运行
JVM
的基础知识A a = new B()
Java
程序 通过 栈上的引用类型数据(reference
) 来访问Java
堆上的对象由于引用类型数据(reference
)在 Java
虚拟机中只规定了一个指向对象的引用,但没定义该引用应该通过何种方式去定位、访问堆中的对象的具体位置
所以对象访问方式 取决于 虚拟机实现。目前主流的对象访问方式有两种:
具体请看如下介绍:
Overload
、前绑定)、方法重写(Override
、后绑定) 下面,我将详细讲解方法重载(Overload
) & 方法重写(Override
)
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!
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)
// 定义类
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()
// 定义类
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()
至此,关于Java
中的多态特性讲解完毕。
Java
中三大特性之一的多态特性,其中着重讲解其表现形式:方法重载(Overload
)、方法重写(Override
)Android & Java
中的知识进行深入讲解 ,有兴趣可以继续关注Carson_Ho的安卓开发笔记