java类的多态

最新推荐文章于 2025-03-22 21:03:20 发布

uppp»

最新推荐文章于 2025-03-22 21:03:20 发布

阅读量863

点赞数 25

分类专栏： java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_73993301/article/details/145546328

版权

java 专栏收录该内容

25 篇文章

订阅专栏

一、什么是多态

定义：父类的引用指向子类的对象

父类 Animal

子类 cat继承Animal

main(){

Cat cat = new Cat();

}

创建子类对象之前创建父类对象

main(){

Animal catAnimal = new Cat();

}

父亲的引用指向子类的对象----多态

数据类型是干什么用的？

基本数据类型
引用数据类型

数据类型决定数据在内存当中的存储形式

二、为什么有多态

多态能解决java语言设计当中的问题——>数据类型的转换(使用向上转型来解决---子类的对象由父类的类型接收)

下面是一些具体的实例：

A.java

public class A {
	public String Show(D obj) {
		return "A and D";
	}
	public String Show(A obj) {
		return "A and A";
	}
	public String Show() {
		return "无参的A";
	}
}

B.java

public class B extends A{
	public String Show(Object obj) {
		return "A and D";
	}
	public String Show(A obj) {
		return "B and A";
	}
	public String Show() {
		return "无参的B";
	}
}

C.java

public class C extends B{

}

D.java

public class D extends B{

}

Test.java

public class Test {
	public static void main(String[] args) {
		A a1 = new A();
		A a2 = new B();
		B b1 = new B();
		C c = new C();
		D d = new D();
		
		System.out.println(a1.Show());//1
		System.out.println(a2.Show());//2
		System.out.println(b1.Show());//3
		
		System.out.println(a1.Show(b1));//4
		System.out.println(a1.Show(c));//5
		System.out.println(a1.Show(d));//6
		
		System.out.println(a2.Show(b1));//7
		System.out.println(a2.Show(c));//8
		System.out.println(a2.Show(d));//9
		
		System.out.println(b1.Show(b1));//10
		System.out.println(b1.Show(c));//11
		System.out.println(b1.Show(d));//12
		
	}
	
}

最终结果：

无参的A
无参的B
无参的B
A and A
A and A
A and D
B and A
B and A
A and D
B and A
B and A
A and D

解释：

创建子类对象之前创建父类对象

先创建的是什么类(内存空间创建了几个类，new B())，再考虑它的数据类型能调用哪些方法(A a2)，不存在的话，再考虑是否需要向上转型

1：内存空间创建了A一个类，a1只能调用A里面的方法，所以直接输出‘无参的A’

2：内存空间先创建父类A，再创建B，a2是A类型的只能调用A里面的方法，调用子类对象要重写父类中的方法，所以输出‘无参的B’

3：内存空间先创建父类A，再创建B，b1是B类型的AB中的方法都可以调用，调用子类对象要重写父类中的方法，所以输出‘无参的B’

4：内存空间创建了A一个类，a1调用A里面的方法，b1是B类型的，a1能调用的方法里面没有B类型的传参，所以向上转型成为A类型的，调用Show(A obj)，输出‘A and A’

5：内存空间创建了A一个类，a1调用A里面的方法，c是C类型的，a1能调用的方法里面没有C类型的传参，所以向上转型成为B类型的，a1能调用的方法里面也没有B类型的传参，所以再向上转型成为A类型的，调用Show(A obj)，输出‘A and A’

6：内存空间创建了A一个类，a1调用A里面的方法，d是D类型的，a1能调用的方法里面有D类型的传参，所以调用Show(D obj)，输出‘A and D’

7：内存空间先创建父类A，再创建B，a2是A类型的只能调用A里面的方法，调用子类对象要重写父类中的方法，a2能调用的方法里面没有B类型的传参，所以向上转型成为A类型的，调用重写之后的Show(A obj)，输出‘B and A’

8：内存空间先创建父类A，再创建B，a2是A类型的只能调用A里面的方法，调用子类对象要重写父类中的方法，c是C类型的，a2能调用的方法里面没有C类型的传参，所以向上转型成为B类型的，a1能调用的方法里面也没有B类型的传参，所以再向上转型成为A类型的，调用Show(A obj)，输出‘B and A’

9：内存空间先创建父类A，再创建B，a2是A类型的只能调用A里面的方法，d是D类型的，a2能调用的方法里面有D类型的传参，所以调用Show(D obj)，输出‘A and D’

10：内存空间先创建父类A，再创建B，b1是B类型的AB中的方法都可以调用，调用子类对象要重写父类中的方法，b1能调用的方法里面没有B类型的传参，所以向上转型成为A类型的，调用重写之后的Show(A obj)，输出‘B and A’

11：内存空间先创建父类A，再创建B，b1是B类型的AB中的方法都可以调用，调用子类对象要重写父类中的方法，c是C类型的，b1能调用的方法里面没有C类型的传参，所以向上转型成为B类型的，b1能调用的方法里面也没有B类型的传参，所以再向上转型成为A类型的，调用重写之后的Show(A obj)，输出‘B and A’