本文详细介绍了Java中的多态性，包括使用多态的前提条件、运行机制及其设计原因。多态主要体现在方法的多态性，编译时检查方法是否为父类定义，运行时根据实际对象调用子类重写的方法。文章还探讨了多态是运行时状态，而方法重载是编译时状态。最后，列举了多态的三个常见应用场景：调用未重写的方法、执行子类特有的方法和利用重写方法表现子类差异。
3 怎么使用多态
3.1 使用多态的前提
两个类之间必须存在父子关系(继承关系)
必须实现了方法的重写,因为多态主要是指的是方法的多态性,和属性没关系
3.2 多态运行的机制
3.2.1 编译期(静态)
内容
编译时看的是左边,编译阶段会检查对象.属性/方法是否是父类里面定义的属性和方法(若父类还有其父亲,也要在父类型特征区去进行寻找),若存在,才允许编译通过,若不存在则编译不通过
编译不通过示例代码
Animal01
package Work;
public class Animal01 {
private String name;
//姓名
private int age;
//年龄
private String sex;
//性别
public Animal01() {
}
public Animal01(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
//使用多态后,父类只需要一个方法就可以使用所有动物对象不同的叫声的功能
public void say(Animal01 animal01){
System.out.println("名字为: "+animal01.getName()+"年龄为: "+animal01.getAge()+"性别为: "+animal01.getSex()+"的狗在汪汪汪");
}
}
Dog01
package Work;
public class Dog01 extends Animal01{
int weight;
//Dog01独有的属性
public Dog01() {
}
public Dog01(String name, int age, String sex) {
super(name, age, sex);
}
}
Test
package Work;
public class Test {
public static void main(String[] args) {
//建立一个父类对象,启动say方法
Animal01 a=new Dog01("王富贵",5,"雌性");
System.out.println(a.weight);;
}
}
错误示例截图
3.2.1 运行期(动态)
内容
因为编译期会把子类的独有方法给过滤掉,因此运行的时候只需要考虑.的方法是否在子类型实例化的空间里面存在了。
运行看的是右边,若子类重写了.调用的方法,那么用多态时候调用的就是子类的方法，若没有重写,调用的是子类中的父类型特征区里面的方法(继承时从父类那边拷贝一份过来的)
示例代码
Animal01类
package Work;
public class Animal01 {
private String name;
//姓名
private int age;
//年龄
private String sex;
//性别
public Animal01() {
}
public Animal01(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public void say(){
System.out.println("动物在说话!!!");
}
public void test(){
System.out.println("测试父类中没有被子类重写的方法是否能被调用");
}
}
Dog01类
package Work;
public class Dog01 extends Animal01{
int weight;
//Dog01独有的属性
public Dog01() {
}
public Dog01(String name, int age, String sex) {
super(name, age, sex);
}
@Override
public void say() {
System.out.println("狗狗在说话");
}
}
Test类
package Work;
public class Test {
public static void main(String[] args) {
//建立一个父类对象,启动say方法
Animal01 a=new Dog01("王富贵",5,"雌性");
a.test();
a.say();
}
}
示例代码运行截图
3.2.3 为什么多态运行的机制要设计成这样???
编译期间
在多个类之间进行参数的传递时,传递的具体是哪个类型,编译器并不清楚。在new的过程中,是哪个类型也不知道,为了保证一定有一个方法能够在运行时期间能够被顺利启动,所以编译期才必须要求调用的方法一定是父类型的方法,调用的属性一定是父类型的属性
运行期间
为了体现子类实例化对象的差异性,例如狗的叫声是汪汪汪,猫的叫声是喵喵喵
3.3 多态是编译时状态还是运行时状态
解答:运行时状态,因为你在编译的过程中并不知道你实例化的对象是什么类型的,只有在方法调用的时候才知道
3.4 方法重载是运行时状态还是编译时状态
解答:方法的重载是编译时状态,因为你在用方法的时候就确定是那个方法了,不会有其他的可能性的。是静态的
3.5 多态的三个常见的使用场景
a 父类中有一个方法且该方法没有被子类重写,不同的子类调用该方法时,想根据子类的类型去得到对应的结果
典型题目
存在一个父类Animal01,子类Dog01、子类Cat01,其中Animal类中有一个say()叫声方法,此方法没有被子类重写,然后你想要Dog01调用say()方法打印汪汪汪,Cat01调用时say()方法时打印喵喵喵
示例代码
Animal01类
package Work;
public class Animal01 {
private String name;
//姓名
private int age;
//年龄
private String sex;
//性别
public Animal01() {
}
public Animal01(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public void say(Animal01 animal01){
if(animal01 instanceof Dog01){
System.out.println("汪汪汪");
}else if(animal01 instanceof Cat01){
System.out.println("喵喵喵");
}
}
}
Cat01类
package Work;
public class Cat01 extends Animal01{
public Cat01() {
}
public Cat01(String name, int age, String sex) {
super(name, age, sex);
}
}
Dog01类
package Work;
public class Dog01 extends Animal01{
public Dog01() {
}
public Dog01(String name, int age, String sex) {
super(name, age, sex);
}
}
Test类
package Work;
public class Test {
public static void main(String[] args) {
//建立一个父类对象animal01,启动say方法
Animal01 animal01=new Animal01();
animal01.say(new Dog01());
animal01.say(new Cat01());
}
}
示例代码运行截图
b 父类中有一个方法且该方法没有被子类重写,不同的子类调用该方法时会去执行其独有的方法
典型题目
存在一个父类Animal01,子类Dog01、子类Cat01,其中Animal类中有一个action()行为方法,此方法没有被子类重写,然后你想要Dog01调用action()方法会调用Dog01中特有的方法guardDoor看门,Cat01调用时action()方法时会去调用Cat01中特有的方法catchMouse()
示例代码
Animal01类
package Work;
public class Animal01 {
private String name;
//姓名
private int age;
//年龄
private String sex;
//性别
public Animal01() {
}
public Animal01(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public void action(Animal01 animal01){
if(animal01 instanceof Dog01){
((Dog01)animal01).guardDoor();
}else if(animal01 instanceof Cat01){
((Cat01)animal01).catchMouse();
}
}
}
Cat01类
package Work;
public class Cat01 extends Animal01{
public Cat01() {
}
public Cat01(String name, int age, String sex) {
super(name, age, sex);
}
public void catchMouse(){
System.out.println("猫咪在捉老鼠");
}
}
Dog01类
package Work;
public class Dog01 extends Animal01{
public Dog01() {
}
public Dog01(String name, int age, String sex) {
super(name, age, sex);
}
public void guardDoor(){
System.out.println("狗狗在看门");
}
}
Test类
package Work;
public class Test {
public static void main(String[] args) {
//建立一个父类对象animal01,启动action方法
Animal01 animal01=new Animal01();
animal01.action(new Dog01());
animal01.action(new Cat01());
}
}
示例代码运行截图
c 父类中有一个方法且该方法被子类重写,不同的子类调用该方法时,调用的是子类中重写的方法,从而表现出子类对象的差异性
典型题目
存在一个父类Animal01,子类Dog01、子类Cat01,其中Animal类中有一个eat()叫声方法,此方法被其所有子类重写,存在一个Master主人类,主人根据不同的实例化对象，进行不同的喂养方法
示例代码
Animal01类
package Work;
public class Animal01 {
private String name;
//姓名
private int age;
//年龄
private String sex;
//性别
public Animal01() {
}
public Animal01(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public void eat(){
System.out.println("父类对象提供方法给子类对象去重写它");
}
}
Cat01类
package Work;
public class Cat01 extends Animal01{
public Cat01() {
}
public Cat01(String name, int age, String sex) {
super(name, age, sex);
}
@Override
public void eat() {
System.out.println("猫咪在吃鱼");
}
}
Dog01类
package Work;
public class Dog01 extends Animal01{
public Dog01() {
}
public Dog01(String name, int age, String sex) {
super(name, age, sex);
}
@Override
public void eat() {
System.out.println("狗在啃骨头");
}
}
Master类
package Work;
public class Master {
public void feed(Animal01 animal01){
animal01.eat();
//不用去进行对象是哪个类型的判断,调用是子类被重写的方法
//结论:只要调用的是子类的重写的方法,那么就无需进行对象的类型的判断
}
}
Test类
package Work;
public class Test {
public static void main(String[] args) {
Master master=new Master();
master.feed(new Dog01());
master.feed(new Cat01());
}
}
示例代码运行截图
1177
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
