day09_面向对象-多态-课后练习 - 参考答案

于 2024-02-22 11:00:01 发布
阅读量385 收藏 7
点赞数 10
分类专栏： JavaSE知识讲解和课后练习 文章标签： java 开发语言 面向对象-多态
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65152767/article/details/136227909
版权

文章目录

day09_课后练习

代码阅读分析题

第1题

考核知识点：属性与多态无关

package com.atguigu.test01;

public class Test01 {
	public static void main(String[] args) {
		A a = new B();
		System.out.println(a.num);
		System.out.println(((B)a).num);
		System.out.println(((A)((B)a)).num);
		System.out.println("-------------------");
		B b = new B();
		System.out.println(b.num);
		System.out.println(((A)b).num);
		System.out.println(((B)((A)b)).num);
	}
}
class A{
	int num = 1;
}
class B extends A{
	int num = 2;
}

/*
 * 多态性现象：编译时类型与运行时类型不一致
 * 但是多态性是针对方法来说，方法有动态绑定一说。
 * 属性没有多态性。属性都是按照编译时类型处理的。
 */
public class Test01 {
	public static void main(String[] args) {
		A a = new B();
		System.out.println(a.num);//a编译时类型就是A  1
		System.out.println(((B)a).num);//编译后，因为a被强制成B类，是B类型  2
		System.out.println(((A)((B)a)).num);//编译后，a转成B又转成A，是A类型   1
		System.out.println("-------------------");
		B b = new B();
		System.out.println(b.num);//b编译时类型就是B   2
		System.out.println(((A)b).num);//b被强制升级为A类型，按A类型处理， 1
		System.out.println(((B)((A)b)).num);//b先转A又转B，最终是B类型  2
	}
}
class A{
	int num = 1;
}
class B extends A{
	int num = 2;
}

第2题

考核知识点：实例初始化方法，属性与多态无关

package com.atguigu.test02;

public class Test02 {
	public static void main(String[] args) {
		Father f = new Son();
		System.out.println(f.x);
	}
}
class Father{
	int x = 10;
	public Father(){
		this.print();
		x = 20;
	}
	public void print(){
		System.out.println("Father.x = " + x);
	}
}
class Son extends Father{
	int x = 30;
	public Son(){
		this.print();
		x = 40;
	}
	public void print(){
		System.out.println("Son.x = " + x);
	}
}

package com.atguigu.test02;

/*
 * 1、Father f = new Son();
 * 实例初始化的过程：
 * （1）父类的实例初始化
 * <init>(){
 * 		x = 10;//父类的x
 * 		this.print();//子类的print，因为this代表的是正在创建的子类对象，而子类重写了print，所以是子类的print'
 * 				System.out.println("Son.x = " + x);//子类的x，此时还没有赋值，那么是默认值x=0
		x = 20;//父类的x
 * }
 * （2）子类的实例初始化
 * <init>(){
 * 		x = 30;//子类的x
 * 		this.print();//子类的print
 * 			System.out.println("Son.x = " + x);//子类的x，此时已经赋值x=30
		x = 40;//子类的x
 * }
 * 
 * 2、执行System.out.println(f.x);
 * 属性没有多态性，只看编译时类型，那么此时f.x表示父类的x
 */
public class Test02 {
	public static void main(String[] args) {
		Father f = new Son();
		System.out.println(f.x);
	}
}
class Father{
	int x = 10;
	public Father(){
		this.print();
		x = 20;
	}
	public void print(){
		System.out.println("Father.x = " + x);
	}
}
class Son extends Father{
	int x = 30;
	public Son(){
		this.print();
		x = 40;
	}
	public void print(){
		System.out.println("Son.x = " + x);
	}
}

第3题

考核知识点：多态，重写，实例初始化过程

package com.atguigu.test03;

public class Test03 {
	public static void main(String[] args) {
		Base b1 = new Base();
		Base b2 = new Sub();
	}
}

class Base {
	Base() {
		method(100);
	}

	public void method(int i) {
		System.out.println("base : " + i);
	}
}

class Sub extends Base {
	Sub() {
		super.method(70);
	}

	public void method(int j) {
		System.out.println("sub : " + j);
	}
}

package com.atguigu.test03;
/*
 * 1、Base b1 = new Base();
 * 父类的实例初始化，和子类无关
 * 
 * <init>(){
 * 		method(100);
 * 			System.out.println("base : " + i);  base:100
 * }
 * 
 * 2、Base b2 = new Sub();
 * （1） 父类的实例初始化
 * 
 * <init>(){
 * 		method(100);//执行了子类重写的method()
 * 			System.out.println("sub : " + j);  sub:100
 * }
 * 
 * （2）子类的实例初始化
 * <init>(){
 * 		super.method(70);
 * 			System.out.println("base : " + i);	base:70
 * }
 */
public class Test03 {
	public static void main(String[] args) {
		Base b1 = new Base();
		Base b2 = new Sub();
	}
}

class Base {
	Base() {
		method(100);
	}

	public void method(int i) {
		System.out.println("base : " + i);
	}
}

class Sub extends Base {
	Sub() {
		super.method(70);
	}

	public void method(int j) {
		System.out.println("sub : " + j);
	}
}

第4题

考核知识点：多态、重载、重写

public class Test04 {
	public static void main(String[] args) {
		A a1 = new A();
		A a2 = new B();
		B b = new B();
		C c = new C();
		D d = new D();
		System.out.println("(1)" + a1.show(b));
		System.out.println("(2)" + a2.show(d));
		System.out.println("(3)" + b.show(c));
		System.out.println("(4)" + b.show(d));
	}
}
class A{
	public String show(D obj){
		return ("A and D");
	}
	public String show(A obj){
		return "A and A";
	}
}
class B extends A{
	public String show(B obj){
		return "B and B";
	}
	public String show(A obj){
		return "B and A";
	}
}
class C extends B{
	
}
class D extends B{
	
}

/*
 * 1、分析方法列表和继承关系
 * A类：
 * 	public String show(D obj) 
 * 	public String show(A obj)
 * B类：
 * 	public String show(D obj)继承的
 * 	public String show(A obj)重写
 * 	public String show(B obj)自定义的
 * C->B->A
 * D->B->A
 * 
 * 2、方法重载：找最合适的形参类型
 * 3、方法重写：如果子类重写，就执行重写的
 * 4、分析执行结果
 * a1.show(b)：a1没有多态引用，直接找A类的方法，b是B类对象，只能选择public String show(A obj)   A and A
 * a2.show(d)：a2多态引用，执行子类的方法，d是D类对象，选最合适的public String show(D obj)   A and D
 * b.show(c)：b没有多态引用，直接找B类的方法，c是C类的对象，选择最合适的public String show(B obj) B and B
 * b.show(d)：b没有多态引用，直接找B类的方法，d是D类对象，选最合适的public String show(D obj)   A and D
 */
public class Test04 {
	public static void main(String[] args) {
		A a1 = new A();
		A a2 = new B();
		B b = new B();
		C c = new C();
		D d = new D();
		System.out.println("(1)" + a1.show(b));
		System.out.println("(2)" + a2.show(d));
		System.out.println("(3)" + b.show(c));
		System.out.println("(4)" + b.show(d));
	}
}

class A {
	public String show(D obj) {
		return ("A and D");
	}

	public String show(A obj) {
		return "A and A";
	}
}

class B extends A {
	public String show(B obj) {
		return "B and B";
	}

	public String show(A obj) {
		return "B and A";
	}
}

class C extends B {

}

class D extends B {

}

第5题

考核知识点：多态、重载、重写

public class Test05 {
	public static void main(String[] args) {
		A a1 = new A();
		A a2 = new B();
		B b = new B();
		C c = new C();
		D d = new D();
		System.out.println("(1)" + a1.show(b));
		System.out.println("(2)" + a2.show(d));
		System.out.println("(3)" + b.show(c));
		System.out.println("(4)" + b.show(d));
	}
}

class A {
	public String show(C obj) {
		return ("A and C");
	}

	public String show(A obj) {
		return "A and A";
	}
}

class B extends A {
	public String show(B obj) {
		return "B and B";
	}

	public String show(A obj) {
		return "B and A";
	}
}

class C extends B {

}

class D extends B {

}

package com.atguigu.test02;

/*
 * 1、分析每个类的方法列表和继承关系
 * A类：
 * 	public String show(C obj) 
 * 	public String show(A obj)
 * B类：
 * 	public String show(C obj)继承的
 * 	public String show(A obj)重写
 * 	public String show(B obj)自定义的
 * C->B->A
 * D->B->A
 * 
 * 2、方法重载：找最合适的形参类型
 * 3、方法重写：如果子类重写，就执行重写的
 * 4、如果特殊的重载，那么多态时，编译时先从父类中查找最合适的形参类型，然后如果子类如果有重写，执行子类重写的，如果没有重写，执行父类的。
 * 5、分析执行结果
 * a1.show(b)：a1没有多态引用，直接找A类的方法，b是B类对象，只能选择public String show(A obj)   A and A
 * a2.show(d)：a2多态引用，执行子类的方法，d是D类对象，但是因为此时编译时按A类编译，所以在编译期间先确定是调用
 * 		public String show(A obj)，而后执行子类重写的public String show(A obj)       B and A
 * 		而不是直接选最合适的public String show(B obj)
 * b.show(c)：b没有多态引用，直接找B类的方法，c是C类的对象，选择最合适的public String show(C obj) A and C
 * b.show(d)：b没有多态引用，直接找B类的方法，d是D类对象，选最合适的public String show(B obj)   B and B
 */
public class Test02 {
	public static void main(String[] args) {
		A a1 = new A();
		A a2 = new B();
		B b = new B();
		C c = new C();
		D d = new D();
		System.out.println("(1)" + a1.show(b));
		System.out.println("(2)" + a2.show(d));
		System.out.println("(3)" + b.show(c));
		System.out.println("(4)" + b.show(d));
	}
}

class A {
	public String show(C obj) {
		return ("A and C");
	}

	public String show(A obj) {
		return "A and A";
	}
}

class B extends A {
	public String show(B obj) {
		return "B and B";
	}

	public String show(A obj) {
		return "B and A";
	}
}

class C extends B {

}

class D extends B {

}

第6题

考核知识点：属性与多态无关

public class Test06 {
	public static void main(String[] args) {
		Base b = new Sub();
		System.out.println(b.x);
	}
}
class Base{
	int x = 1;
}
class Sub extends Base{
	int x = 2;
}

package com.atguigu.test06;

/*
 * 属性没有多态性，只看编译时类型
 */
public class Test06 {
	public static void main(String[] args) {
		Base b = new Sub();
		System.out.println(b.x);
	}
}
class Base{
	int x = 1;
}
class Sub extends Base{
	int x = 2;
}

在这里插入图片描述

小丁学Java
关注
  • 10
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
博客
固定Linux的ip地址，通过图形化界面操作，简单易上手
05-27 937
固定Linux的ip地址，通过图形化界面操作，简单易上手。
博客
运行SpringBootTest报 UnsatisfiedDependencyException 和 NoSuchBeanDefinitionException 异常的解决思路分析
05-22 549
运行SpringBootTest报 UnsatisfiedDependencyException 和 NoSuchBeanDefinitionException 异常的解决思路分析。
博客
kafka-生产者-发送对象消息（SpringBoot整合Kafka）
06-06
kafka-生产者-发送对象消息（SpringBoot整合Kafka）
博客
kafka-消费者-消费异常处理（SpringBoot整合Kafka）
06-06 243
kafka-消费者-消费异常处理。
博客
kafka-消费者-设置 ack-mode: manual_immediate和acknowledgment.acknowledge()避免重复消费（SpringBoot整合Kafka）
06-06 516
kafka-消费者-设置 ack-mode: manual_immediate和acknowledgment.acknowledge()避免重复消费。
博客
kafka-消费者-设置 ack-mode: manual_immediate 会导致消息重复消费（SpringBoot整合Kafka）
06-06 470
kafka-消费者-设置 ack-mode: manual_immediate 会导致消息重复消费。
博客
kafka-消费者-指定offset消费（SpringBoot整合Kafka）
06-06 182
kafka-消费者-指定offset消费（SpringBoot整合Kafka）
博客
kafka-消费者-指定分区消费（SpringBoot整合Kafka）
06-06 126
kafka-消费者-指定分区消费（SpringBoot整合Kafka）
博客
kafka-消费者-注解接收消息（SpringBoot整合Kafka）
06-06 76
kafka-消费者-注解接收消息（SpringBoot整合Kafka）
博客
kafka-消费者组（SpringBoot整合Kafka）
06-06 191
kafka-消费者组。
博客
kafka-消费者服务搭建&配置&简单消费（SpringBoot整合Kafka）
06-05 1053
kafka-消费者服务搭建&配置（SpringBoot整合Kafka）
博客
kafka-生产者事务-数据传递语义&事务介绍&事务消息发送（SpringBoot整合Kafka）
06-05 313
kafka-生产者事务-数据传递语义&事务介绍&事务消息发送。
博客
kafka-生产者监听器（SpringBoot整合Kafka）
06-04 215
kafka-生产者监听器（SpringBoot整合Kafka）
博客
kafka-生产者拦截器（SpringBoot整合Kafka）
06-04 481
kafka-生产者拦截器（SpringBoot整合Kafka）
博客
Linux中，ll 命令 列出目录的内容
06-04 857
然后，你需要重新加载你的shell配置文件或者重新启动你的shell会话以使这个更改生效。如果你想要查看或编辑这些别名，你可以打开你的shell配置文件（具体是哪个文件取决于你的系统和配置），然后搜索。通过“ll”命令可以快速、详细地了解当前目录下的文件和目录的具体情况，对于系统管理和文件操作非常有用。表示符号链接，后面跟着表示读、写、执行权限的 rwx 字符串，以及所有者、所属组和其他用户的权限。文件中定义，目的是为了方便用户查看文件和目录的详细信息。所有者和所属组：列出文件或目录的所有者和所属组。
博客
spring-kafka-生产者服务搭建&测试（SpringBoot整合Kafka）
06-04 406
spring-kafka-生产者服务搭建&测试（SpringBoot整合Kafka）
博客
kafka-集群-生产消费测试
06-04 161
kafka-集群-生产消费测试。
博客
kafka-集群-主题创建
06-03 160
kafka-集群-主题创建。
博客
docker命令 docker ps -l （latest）命令在 Docker 中用于列出最近一次创建的容器
06-03 470
在这个示例中，我们可以看到最近创建的一个名为 “my-nginx” 的容器，它基于 “nginx:latest” 镜像，并且正在运行。命令会返回最近一次启动的容器的信息，包括容器ID、所使用的镜像、状态、端口映射、启动时间等。这个命令对于跟踪当前正在运行的容器非常有用，特别是当你需要查看最近发生了什么或者需要重启一个刚刚停止的容器时。这个命令会列出所有正在运行的容器，然后只显示最新创建的一个容器的详细信息。它只列出最近一次创建的那个容器的详细情况，包括容器 ID、镜像、命令、创建时间等关键信息。
博客
kafka-集群搭建（在docker中搭建）
06-03 504
kafka-集群搭建（在docker中搭建）

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值