java知识3-----核心2-面向对象高级 续1--对象多态性

已于 2022-07-28 14:38:43 修改
阅读量256 收藏
点赞数
分类专栏： 知识归档 文章标签： java 开发语言 junit
于 2022-07-27 15:48:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jakezhang1990/article/details/126011285
版权

目录标题

对象多态性

多态性在面向对象中是最重要的，在java中面向对象多态性主要有以下两种主要体现：
1，方法的重载与覆写；
2，对象的多态性；
面向对象三个特性：
封装，是为了保护类中的属性不被外部直接访问到；
继承，是为了扩展类的功能；
多态，方法的重载、覆写；对象的多态；
对象的多态性，主要分为向上转型和向下转型。
在这里插入图片描述

面向对象向上转型、向下转型

向上转型

向上转型：子类对象用父类接收；对于向上转型程序会自动完成；

父类 父类对象 = 子类实例；

向下转型：父类对象转为子类对象，对于向下转型必须明确指明要转型的子类类型。

子类 子类对象 = （子类）父类实例；

class A{					// 定义类A
	public void fun1(){		// 定义fun1()方法
		System.out.println("A --> public void fun1(){}") ;
	}
	public void fun2(){
		this.fun1() ;		// 调用fun1()方法
	}
};
class B extends A{
	public void fun1(){		// 此方法被子类覆写了
		System.out.println("B --> public void fun1(){}") ;
	}
	public void fun3(){
		System.out.println("B --> public void fun3(){}") ;
	}
};
public class PolDemo01{
	public static void main(String asrgs[]){
		B b = new B() ;		// 实例化子类对象
		b.fun1() ;			// 此方法被子类覆写过
	}
};

fun1()被子类覆写过，所以子类对象调用的时候，肯定是调用了覆写过的方法。
在这里插入图片描述

class A{					// 定义类A
	public void fun1(){		// 定义fun1()方法
		System.out.println("A --> public void fun1(){}") ;
	}
	public void fun2(){
		this.fun1() ;		// 调用fun1()方法
	}
};
class B extends A{
	public void fun1(){		// 此方法被子类覆写了
		System.out.println("B --> public void fun1(){}") ;
	}
	public void fun3(){
		System.out.println("B --> public void fun3(){}") ;
	}
};
public class PolDemo01{
	public static void main(String asrgs[]){
		B b = new B() ;		// 实例化子类对象
		A a = b ;			// 向上转型关系
		a.fun1() ;			// 此方法被子类覆写过
	}
};

进行向上转型，运行后可以发现，子类对象向上转型成父类对象后，调用的方法依然是子类覆写过的方法。
在这里插入图片描述

class A{					// 定义类A
	public void fun1(){		// 定义fun1()方法
		System.out.println("A --> public void fun1(){}") ;
	}
	public void fun2(){
		this.fun1() ;		// 调用fun1()方法
	}
};
class B extends A{
	public void fun1(){		// 此方法被子类覆写了
		System.out.println("B --> public void fun1(){}") ;
	}
	public void fun3(){
		System.out.println("B --> public void fun3(){}") ;
	}
};
public class PolDemo01{
	public static void main(String asrgs[]){
		B b = new B() ;		// 实例化子类对象
		A a = b ;			// 向上转型关系
		a.fun1() ;			// 此方法被子类覆写过
		a.fun2() ;
	}
};

调用父类的fun2（）方法，fun2（）中去调用的fun1()依然是子类覆写过的fun1()。
在这里插入图片描述
结论：
可以发现，通过子类进行父类对象的实例化操作，即对象发生向上转型之后，如果调用的方法被子类覆写过，则调用的肯定都是子类中覆写过的方法，但是当方法没有被覆写过，则调用的就是父类中继承过来的方法，也就是从父类中去找的方法。
注意点：
转型后，因为操作的是父类对象，所以是无法找到在子类中定义的新方法的。

class A{					// 定义类A
	public void fun1(){		// 定义fun1()方法
		System.out.println("A --> public void fun1(){}") ;
	}
	public void fun2(){
		this.fun1() ;		// 调用fun1()方法
	}
};
class B extends A{
	public void fun1(){		// 此方法被子类覆写了
		System.out.println("B --> public void fun1(){}") ;
	}
	public void fun3(){
		System.out.println("B --> public void fun3(){}") ;
	}
};
public class PolDemo01{
	public static void main(String asrgs[]){
		B b = new B() ;		// 实例化子类对象
		A a = b ;			// 向上转型关系
		a.fun1() ;			// 此方法被子类覆写过
		a.fun3() ;
	}
};

向上转型以后，找不到子类中定义的新方法。
在这里插入图片描述

向下转型

将父类对象变为子类对象，称为向下转型。向下转型需要采用强制的手段。

class A{					// 定义类A
	public void fun1(){		// 定义fun1()方法
		System.out.println("A --> public void fun1(){}") ;
	}
	public void fun2(){
		this.fun1() ;		// 调用fun1()方法
	}
};
class B extends A{
	public void fun1(){		// 此方法被子类覆写了
		System.out.println("B --> public void fun1(){}") ;
	}
	public void fun3(){
		System.out.println("B --> public void fun3(){}") ;
	}
};
public class PolDemo02{
	public static void main(String asrgs[]){
		A a = new B() ;			// 向上转型关系
		B b = (B)a ;		// 发生了向下转型关系
		b.fun1() ;
		b.fun2() ;
		b.fun3() ;
	}
};

类B中存在3个方法，所以都可以调用到。
在这里插入图片描述
在进行对象向下转型操作之前，有一股注意点：

class A{					// 定义类A
	public void fun1(){		// 定义fun1()方法
		System.out.println("A --> public void fun1(){}") ;
	}
	public void fun2(){
		this.fun1() ;		// 调用fun1()方法
	}
};
class B extends A{
	public void fun1(){		// 此方法被子类覆写了
		System.out.println("B --> public void fun1(){}") ;
	}
	public void fun3(){
		System.out.println("B --> public void fun3(){}") ;
	}
};
public class PolDemo03{
	public static void main(String asrgs[]){
		A a = new A() ;			// 实例化了一个父类对象
		B b = (B)a ;		// 发生了向下转型关系
		b.fun1() ;
		b.fun2() ;
		b.fun3() ;
	}
};

编译时候没有任何的语法问题，但是在执行的时候报错，一个既空指针异常之后的又一个非常经典的错误，类型转换异常：
在这里插入图片描述
此异常是在对象强转的时候会出现，如果两个没有关系的对象，发生转换关系则肯定出现此异常。
分析：
仅仅知道A类的情况下，并不知道谁是它的子类；
但是知道B类的情况下，就可以通过B extends A，知道B是A的子类，这样，就知道了A和B两个类是有关系的；
发生向下转型之前已经发生了向上转型，然后再进行了向下转型，才不会有任何问题；例如：A a = new B() ; B b = (B)a ;
当直接进行向下转型，肯定是会报类型转换异常的。比如：A a = new A() ; B b = (B)a ;

设计一个方法，可以接收A类的任意子类对象。

方案一：不使用对象多态性，使用重载实现：

class A{					// 定义类A
	public void fun1(){		// 定义fun1()方法
		System.out.println("A --> public void fun1(){}") ;
	}
	public void fun2(){
		this.fun1() ;		// 调用fun1()方法
	}
};
class B extends A{
	public void fun1(){		// 此方法被子类覆写了
		System.out.println("B --> public void fun1(){}") ;
	}
	public void fun3(){
		System.out.println("B --> public void fun3(){}") ;
	}
};
class C extends A{
	public void fun1(){		// 此方法被子类覆写了
		System.out.println("C --> public void fun1(){}") ;
	}
	public void fun5(){
		System.out.println("C --> public void fun5(){}") ;
	}
};
public class PolDemo04{
	public static void main(String asrgs[]){
		fun(new B()) ;	// 传递B的实例
		fun(new C()) ;	// 传递B的实例
	}
	public static void fun(B b){
		b.fun1() ;		// 调用覆写父类中的fun1()方法
	}
	public static void fun(C c){
		c.fun1() ;		// 调用覆写父类中的fun1()方法
	}
};

重载思路方案也是有局限性，没增加一个子类，fun()方法就得重载一次，如果有成百上千的子类的话，就得重载成百上千个方法了。
为了解决这样的局限性，就得使用对象多态性完成。
方案二：对象多态性实现：

class A{					// 定义类A
	public void fun1(){		// 定义fun1()方法
		System.out.println("A --> public void fun1(){}") ;
	}
	public void fun2(){
		this.fun1() ;		// 调用fun1()方法
	}
};
class B extends A{
	public void fun1(){		// 此方法被子类覆写了
		System.out.println("B --> public void fun1(){}") ;
	}
	public void fun3(){
		System.out.println("B --> public void fun3(){}") ;
	}
};
class C extends A{
	public void fun1(){		// 此方法被子类覆写了
		System.out.println("C --> public void fun1(){}") ;
	}
	public void fun5(){
		System.out.println("C --> public void fun5(){}") ;
	}
};
public class PolDemo05{
	public static void main(String asrgs[]){
		fun(new B()) ;	// 传递B的实例
		fun(new C()) ;	// 传递B的实例
	}
	public static void fun(A a){
		a.fun1() ;		// 调用覆写父类中的fun1()方法
	}
};

父类对象接收子类实例；这样，不管有多少个子类，都可以轻松完成，不用再重载方法。

面向对象转型的限制

向上转型：自动完成。
向下转型：强制手段进行，发生向下转型之前，必须先发生向上的转型关系。
对象多态性可以解决方法接收参数的问题。

instanceof

instanceof关键字的作用及使用时机

在java中可以使用instanceof关键字判断，一个对象是哪个类的实例。

对象 instanceof 类    ---> 返回一个boolean类型

class A{					// 定义类A
	public void fun1(){
		System.out.println("A --> public void fun1(){}") ;
	}
	public void fun2(){
		this.fun1() ;		// 调用fun1()方法
	}
};
class B extends A{
	public void fun1(){
		System.out.println("B --> public void fun1(){}") ;
	}
	public void fun3(){
		System.out.println("B --> public void fun3(){}") ;
	}
};
public class InstanceofDemo01{
	public static void main(String asrgs[]){
		A a1 = new B() ;
		System.out.println("A a1 = new B() " + (a1 instanceof A)) ;
		System.out.println("A a1 = new B() " + (a1 instanceof B)) ;
		A a2 = new A() ;
		System.out.println("A a2 = new A() " + (a2 instanceof A)) ;
		System.out.println("A a2 = new A() " + (a2 instanceof B)) ;
	}
};

在这里插入图片描述
a1是A的实例，也是B的实例；
a2是A的实例，但是并不是B的实例，所以a2是无法发生向下转型的，因为a2和类B是没有关系的。

使用instanceof对对象的转型进行安全验证

例子：
A类是父类，B是A的子类，C也是A的子类；判断，如果是B类则调用B类覆写过的fun1()方法后调用B类中新定义的fun3()方法；如果是C类则掉员工C类覆写过的fun1()方法然后调用C类中新定义的fun5()方法。
（对象发生向上转型以后，就相当于是父类对象了，对象只能调用子类覆写过的方法，对于子类中新定义的方法是无法访问到的）

class A{					// 定义类A
	public void fun1(){		// 定义fun1()方法
		System.out.println("A --> public void fun1(){}") ;
	}
	public void fun2(){
		this.fun1() ;		// 调用fun1()方法
	}
};
class B extends A{
	public void fun1(){		// 此方法被子类覆写了
		System.out.println("B --> public void fun1(){}") ;
	}
	public void fun3(){
		System.out.println("B --> public void fun3(){}") ;
	}
};
class C extends A{
	public void fun1(){		// 此方法被子类覆写了
		System.out.println("C --> public void fun1(){}") ;
	}
	public void fun5(){
		System.out.println("C --> public void fun5(){}") ;
	}
};
public class InstanceofDemo02{
	public static void main(String asrgs[]){
		fun(new B()) ;
		fun(new C()) ;
	}
	public static void fun(A a){
		a.fun1() ;
		if(a instanceof B){
			B b = (B) a ;
			b.fun3() ;
		}
		if(a instanceof C){
			C c = (C) a ;
			c.fun5() ;
		}
	}
};

在开发中对于向下转型，最好增加验证，保证转型时不发生ClassCastException。
如果现在增加A的这类，则就需要修改fun()方法，这样一来，程序就失去了灵活性和可维护性。问题出在哪里？父类的设计不合理，需要把父类重新设计，否则开发中会非常难以维护。

开发设计原则：
一个类永远不要去继承一个已经实现好的类，而是去继承抽象类或者实现接口。
父类一般都设计成抽象类或者接口。

费城之鹰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java面向对象（进阶）- 面向对象特征之三：多态性
11-11
Java面向对象（进阶）-- 面向对象特征之三：多态性
Java多态性理解
weixin_33766805的博客
10-29 701
Java中多态性的实现 什么是多态 面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。 多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用） 实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引...
Java之 多态（方法重载、方法覆写、对象的向上、向下转型）
C_U_N_Z的博客
03-15 386
在Java中，多态的核心表现主要有以下俩点： 1. 方法的多态性： ①方法的重载：同一个方法名称可以根据参数的类型或者个数不同调用不同的方法体。 eg：构造参数重载： public Person(){ System.out.println("===无参构造==="); } public Person(String n){ name = n; System.out....
java面向对象基础 — — 多态性
mocoll的博客
08-27 276
四、多态性 4.1、概述 面向对象三大特征:封装性、继承性、多态性。 extends继承或者implements实现，是多态性的前提。 4.2、多态的格式与使用 代码当中体现多态性，其实就是一句话: 父类引用指向子类对象。 格式: ​ 父类名称 对象名 = new 子类名称(); 或者: ​ 接口名称 对象名 = new 实现类名称(); 4.2、多态中成员变量的访问特点 访问成员变量的两种方式： ① 直接通过对象名称访问成员变量: 看等号左边是谁，优先用谁，没有则向上找 ② 间接通过成员方法访
java面向对象多态,Java 面向对象 之 多态
weixin_30303283的博客
03-16 90
/**知识点： 多态 Polymorphism1. 对象的多态性分为三种: 方法的重载, 方法的覆盖, 对象的向上向下转型2. 基本类型的向上向下转型3. 对象的向上向下转型 : 必须发生在子类和父类之间注意:1. 子类对象 可以 转换成父类对象 但是转换后子类属性和方法不可见当再转换成子类的时候 要强制类型转换2. 如果直接实例父类然后 转成子类不允许 报异常 ClassCastExceptio...
Java-Java面向对象多态性教程
11-09
Java 面向对象多态性教程 资源为视频教程资源 希望对你的 Java 学习有所帮助。
C++面向对象程序设计-章-多态性-虚函数(与“函数”有关文档共45张).pptx
11-18
C++面向对象程序设计-章-多态性-虚函数(与“函数”有关文档共45张).pptx
商业编程-源码-使用三态树实现多目录选择.zip
06-23
商业编程-源码-使用三态树实现多目录选择.zip
论文研究 - 5-HTTLPR遗传多态性与创伤后应激障碍的相关研究
05-23
这项研究的目的是调查在中国地震幸存者样本中诊断为创伤后应激障碍（PTSD）的患者血清素转运蛋白基因（5-HTTLPR）多态性的影响。 进行聚合酶链反应（PCR）扩增和扩增的片段长度多态性（AFLP），以对57例PTSD患者和...
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 456
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1541
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 712
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
Lambda表达式特点
最新发布
weixin_57763462的博客
04-24 639
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
第5 章 Consul服务注册与发现
a13763926743的博客
04-22 793
consul官网地址。
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 252
待更新。
Mybatis-动态SQL
weixin_43866613的博客
04-24 835
Mybatis的xml映射文件，以及动态SQL的应用
迭代器模式
LuckFairyLuckBaby的博客
04-23 584
迭代器模式(Iterator),提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
Java | 冒泡排序算法实现
yingzix688的博客
04-24 733
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
安装和部署maven
weixin_44014460的博客
04-21 260
maven本地部署和集成到jenkins详细步骤
c++ 面向对象 - 类的多态性与虚函数
06-28
C++面向对象中的多态性是指同一种类型的对象在不同的情况下表现出不同的行为。这种多态性可以通过虚函数来实现。 在C++中，虚函数是指在基类中声明的函数，在派生类中可以被重写，从而实现不同的行为。当使用基类...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值