面向对象-多态

新手小白学JAVA 面向对象之多态 4 多态 4.1 概念 多态指同一个实体同时具有多种形式 它是面向对象程序设计(OOP)的一个重要特征。 主要是指同一个对象,在不同时刻,代表的对象不一样,指的是对象的多种形态。 好处是:可以把不同的子类对象都当作父类来看,可以屏蔽不同子类对象之间的差异,写出通用的代码,做出通用的编程,统一调用标准。 水果有两种形态:水果和苹果,不关心买回来的是苹果还是西瓜,只要是水果就行 class Animal{//1.定义父类Animal …eat(){syso(“吃啥都行”)} } class Cat exte 阅读详情

多态(掌握)

(1)同一个对象在不同时刻体现出来的不同状态。

(2)多态的前提:

    A:有继承或者实现关系。

    B:有方法重写。

    C:有父类或者父接口引用指向子类对象。

    多态的分类:

        a:具体类多态

            class Fu {}

            class Zi extends Fu {}

            Fu f = new Zi();

        b:抽象类多态

            abstract class Fu {}

            class Zi extends Fu {}

            Fu f = new Zi();

        c:接口多态

            interface Fu {}

            class Zi implements Fu {}

            Fu f = new Zi();

(3)多态中的成员访问特点

    A:成员变量

        编译看左边,运行看左边

    B:构造方法

        子类的构造都会默认访问父类构造

    C:成员方法

        编译看左边,运行看右边

    D:静态方法

        编译看左边,运行看左边


/*
	多态:同一个对象(事物),在不同时刻体现出来的不同状态。
	举例:
		猫是猫,猫是动物。
		水(液体,固体,气态)。
		
	多态的前提:
		A:要有继承关系。
		B:要有方法重写。
			其实没有也是可以的,但是如果没有这个就没有意义。
				动物 d = new 猫();
				d.show();
				动物 d = new 狗();
				d.show();
		C:要有父类引用指向子类对象。
			父 f =  new 子();
			
	用代码体现一下多态。
	
	多态中的成员访问特点:变量没有重写,用的还是父亲的;因为方法有重写,父类方法被子类覆盖掉了,只留下子类的方法
		A:成员变量
			编译看左边,运行看左边。
		B:构造方法
			创建子类对象的时候,访问父类的构造方法,对父类的数据进行初始化。
		C:成员方法
			编译看左边,运行看右边。
		D:静态方法
			编译看左边,运行看左边。
			(静态和类相关,算不上重写,所以,访问还是左边的)
			
		由于成员方法存在方法重写,所以它运行看右边。
*/
public class Fu {
	public int num = 100;

	public void show() {
		System.out.println("show Fu");
	}

	public static void function() {
		System.out.println("function Fu");
	}
}

public class Zi extends Fu {
	public int num = 1000;
	public int num2 = 200;

	public void show() {
		System.out.println("show Zi");
	}
	
	public void method() {
		System.out.println("method zi");
	}
	
	public static void function() {
		System.out.println("function Zi");
	}
}

public class DuoTaiDemo {
	
	public static void main(String[] args) {
		//要有父类引用指向子类对象。
		//父 f =  new 子();
		Fu f = new Zi();
		System.out.println(f.num);   //100
		//System.out.println(f.num2);//报错:找不到符号
		
		f.show();     //show Zi
		//f.method(); //报错:找不到符号
		f.function(); //function Fu
	}

}

(4)多态的好处:

    A:提高代码的维护性(继承体现)

    B:提高代码的扩展性(多态体现)


/*
	多态的好处:
		A:提高了代码的维护性(继承保证)
		B:提高了代码的扩展性(由多态保证)
		
	猫狗案例代码
*/
class Animal {
	public void eat(){
		System.out.println("eat");
	}
	
	public void sleep(){
		System.out.println("sleep");
	}
}

class Dog extends Animal {
	public void eat(){
		System.out.println("狗吃肉");
	}
	
	public void sleep(){
		System.out.println("狗站着睡觉");
	}
}

class Cat extends Animal {
	public void eat() {
		System.out.println("猫吃鱼");
	}
	
	public void sleep() {
		System.out.println("猫趴着睡觉");
	}
}

class Pig extends Animal {
	public void eat() {
		System.out.println("猪吃白菜");
	}
	
	public void sleep() {
		System.out.println("猪侧着睡");
	}
}

//针对动物操作的工具类
class AnimalTool {
	private AnimalTool(){}

	/*
	//调用猫的功能
	public static void useCat(Cat c) {
		c.eat();
		c.sleep();
	}
	
	//调用狗的功能
	public static void useDog(Dog d) {
		d.eat();
		d.sleep();
	}
	
	//调用猪的功能
	public static void usePig(Pig p) {
		p.eat();
		p.sleep();
	}
	*/
	public static void useAnimal(Animal a) {
		a.eat();
		a.sleep();
	}
	
}

class DuoTaiDemo2 {
	public static void main(String[] args) {
		//我喜欢猫,就养了一只
		Cat c = new Cat();
		c.eat();
		c.sleep();
		
		//我很喜欢猫,所以,又养了一只
		Cat c2 = new Cat();
		c2.eat();
		c2.sleep();
		
		//我特别喜欢猫,又养了一只
		Cat c3 = new Cat();
		c3.eat();
		c3.sleep();
		//...
		System.out.println("--------------");
		/*
		问题来了,我养了很多只猫,每次创建对象是可以接受的
		但是呢?调用方法,你不觉得很相似吗?仅仅是对象名不一样。
		我们准备改进
		*/
		//useCat(c);
		//useCat(c2);
		//useCat(c3);
		
		//AnimalTool.useCat(c);
		//AnimalTool.useCat(c2);
		//AnimalTool.useCat(c3);
		
		AnimalTool.useAnimal(c);
		AnimalTool.useAnimal(c2);
		AnimalTool.useAnimal(c3);
		System.out.println("--------------");
		
		//我喜欢狗
		Dog d = new Dog();
		Dog d2 = new Dog();
		Dog d3 = new Dog();
		//AnimalTool.useDog(d);
		//AnimalTool.useDog(d2);
		//AnimalTool.useDog(d3);
		AnimalTool.useAnimal(d);
		AnimalTool.useAnimal(d2);
		AnimalTool.useAnimal(d3);
		System.out.println("--------------");
		
		//我喜欢宠物猪
		//定义一个猪类,它要继承自动物,提供两个方法,并且还得在工具类中添加该类方法调用
		Pig p = new Pig();
		Pig p2 = new Pig();
		Pig p3 = new Pig();
		//AnimalTool.usePig(p);
		//AnimalTool.usePig(p2);
		//AnimalTool.usePig(p3);
		AnimalTool.useAnimal(p);
		AnimalTool.useAnimal(p2);
		AnimalTool.useAnimal(p3);
		System.out.println("--------------");
		
		/*
		我喜欢宠物狼,老虎,豹子...
		定义对应的类,继承自动物,提供对应的方法重写,并在工具类添加方法调用
		前面几个必须写,我是没有意见的
		但是,工具类每次都改,麻烦不
		我就想,你能不能不改了
		太简单:把所有的动物都写上。问题是名字是什么呢?到底哪些需要被加入呢?
		改用另一种解决方案。
		public static void useAnimal(Animal a) {
			a.eat();
			a.sleep();
		}
		*/
		
	}
	
}

(5)多态的弊端:

    父不能使用子的特有功能。

    现象:

        子可以当作父使用,父不能当作子使用。


/*
	多态的弊端:
		不能使用子类的特有功能。
*/
class Fu {
	public void show() {
		System.out.println("show fu");
	}
}

class Zi extends Fu {
	public void show() {
		System.out.println("show zi");
	}
	
	public void method() {
		System.out.println("method zi");
	}

}

class DuoTaiDemo3 {
	public static void main(String[] args) {
		//测试
		Fu f = new Zi();
		f.show();  //show zi
		f.method();//报错:方法未定义
	}
}

(6)多态中的转型

    A:向上转型

        从子到父,父类引用指向子类对象:Fu f = new Zi();

    B:向下转型

        从父到子,父类引用转为子类对象:Zi  z = (Zi)f;


/*
	多态的弊端:
		不能使用子类的特有功能。
		
	我就想使用子类的特有功能?行不行?
		行。
		
	怎么用呢?
		A:创建子类对象调用方法即可。(可以,但是很多时候不合理。而且,太占内存了)
		B:把父类的引用强制转换为子类的引用。(向下转型)
		
	对象间的转型问题:
		向上转型:
			Fu f = new Zi();
		向下转型:
			Zi z = (Zi)f; //要求该f必须是能够转换为Zi的。
*/
class Fu {
	public void show() {
		System.out.println("show fu");
	}
}

class Zi extends Fu {
	public void show() {
		System.out.println("show zi");
	}
	
	public void method() {
		System.out.println("method zi");
	}

}

class DuoTaiDemo4 {
	public static void main(String[] args) {
		//测试
		Fu f = new Zi();
		f.show();  //show zi
		//f.method();//报错:方法未定义
		
		//创建子类对象,可以,但是很多时候不合理。而且,太占内存了。
		//Zi z = new Zi();
		//z.show();
		//z.method();
		
		//你能够把子的对象赋值给父亲,那么我能不能把父的引用赋值给子的引用呢?
		//如果可以,代码如下:
		//向下转型
		Zi z = (Zi)f;
		z.show();  //show zi
		z.method();//method zi
	}
}

(7)孔子装爹的案例帮助大家理解多态

多态的问题理解:
	class 孔子爹 {
		public int age = 40;
		
		public void teach() {
			System.out.println("讲解JavaSE");
		}
	}
	
	class 孔子 extends 孔子爹 {
		public int age = 20;
		
		public void teach() {
			System.out.println("讲解论语");
		}
		
		public void playGame() {
			System.out.println("英雄联盟");
		}
	}
	
	//Java培训特别火,很多人来请孔子爹去讲课,这一天孔子爹被请走了
	//但是还有人来请,就剩孔子在家,价格还挺高。孔子一想,我是不是可以考虑去呢?
	//然后就穿上爹的衣服,带上爹的眼睛,粘上爹的胡子。就开始装爹
	//向上转型
	孔子爹 k爹 = new 孔子();
	//到人家那里去了
	System.out.println(k爹.age);      //40
	System.out.println(k爹.teach());  //讲解论语
	//k爹.playGame();                 //这不行,这是儿子才能做的
	
	
	//讲完了,下班回家了,脱下爹的装备,换上自己的装备
	//向下转型
	孔子 k = (孔子) k爹; 
	System.out.println(k.age); //20
	k.teach();                 //讲解论语
	k.playGame();              //英雄联盟


补充:多态继承中的内存图解


补充:一般在多态的向下转型中容易出现ClassCastException:类型转换异常



/*
	ClassCastException:类型转换异常
	一般在多态的向下转型中容易出现
*/
class Animal {
	public void eat(){}
}

class Dog extends Animal {
	public void eat() {}
	
	public void lookDoor() {
	
	}
}

class Cat extends Animal {
	public void eat() {
	
	}
	
	public void playGame() {
		
	}
}

class DuoTaiDemo5 {
	public static void main(String[] args) {
		//内存中的是狗
		Animal a = new Dog();
		Dog d = (Dog)a;
		
		//内存中是猫
		a = new Cat();
		Cat c = (Cat)a;
		
		//内存中是猫
		Dog dd = (Dog)a; //ClassCastException
	}
}

(8)多态的练习


/*
	多态练习:猫狗案例
*/
class Animal {
	public void eat(){
		System.out.println("吃饭");
	}
}

class Dog extends Animal {
	public void eat() {
		System.out.println("狗吃肉");
	}
	
	public void lookDoor() {
		System.out.println("狗看门");
	}
}

class Cat extends Animal {
	public void eat() {
		System.out.println("猫吃鱼");
	}
	
	public void playGame() {
		System.out.println("猫捉迷藏");
	}
}

class DuoTaiTest {
	public static void main(String[] args) {
		//定义为狗
		Animal a = new Dog();
		a.eat();//狗吃肉

		//还原成狗
		Dog d = (Dog)a;
		d.eat();     //狗吃肉
		d.lookDoor();//狗看门

		//变成猫
		a = new Cat();
		a.eat();//猫吃鱼

		//还原成猫
		Cat c = (Cat)a;
		c.eat();     //猫吃鱼
		c.playGame();//猫捉迷藏

		
		//演示错误的内容
		//Dog dd = new Animal();//不兼容的类型
		//Dog ddd = new Cat();  //不兼容的类型
		
		//Dog dd = (Dog)a;      //ClassCastException
		
	}
}	


/*
	不同地方饮食文化不同的案例
*/
class Person {
	public void eat() {
		System.out.println("吃饭");
	}
}

class SouthPerson extends Person {
	public void eat() {
		System.out.println("炒菜,吃米饭");
	}
	
	public void jingShang() {
		System.out.println("经商");
	}
}

class NorthPerson extends Person {
	public void eat() {
		System.out.println("炖菜,吃馒头");
	}
	
	public void yanJiu() {
		System.out.println("研究");
	}
}

class DuoTaiTest2 {
	public static void main(String[] args) {
		//测试
		//南方人
		Person p = new SouthPerson();
		p.eat();         //炒菜,吃米饭

		SouthPerson sp = (SouthPerson)p;
		sp.eat();        //炒菜,吃米饭
		sp.jingShang();  //经商

		
		//北方人
		p = new NorthPerson();
		p.eat();         //炖菜,吃馒头

		NorthPerson np = (NorthPerson)p;
		np.eat();        //炖菜,吃馒头
		np.yanJiu();     //研究
	}
}

看程序写结果:

/*
	看程序写结果:先判断有没有问题,如果没有,写出结果
	
	多态的成员访问特点:
		方法:编译看左边,运行看右边。
		
	继承的时候:
		子类中有和父类中一样的方法,叫重写。
		子类中没有父亲中出现过的方法,方法就被继承过来了。
*/
class A {
	public void show() {
		show2();
	}
	public void show2() {
		System.out.println("我");
	}
}
class B extends A {
	/*可以理解存在该代码,因为继承了父类的方法
	public void show() {
		show2();
	}
	*/

	public void show2() {
		System.out.println("爱");
	}
}
class C extends B {
	public void show() {
		super.show();
	}
	public void show2() {
		System.out.println("你");
	}
}
public class DuoTaiTest4 {
	public static void main(String[] args) {
		A a = new B();
		a.show();  //爱
		
		B b = new C();
		b.show();  //你
	}
}


Ubuntu20.04下Intel RealSense D435i相机驱动配置全攻略(含ROS Noetic适配) 本文详细介绍了在Ubuntu20.04系统下配置Intel RealSense D435i相机驱动的完整流程,包括libRealsense SDK 2.0安装、ROS Noetic适配及常见问题解决方案。通过实战指南帮助开发者快速实现深度相机与ROS的集成,适用于机器人视觉和SLAM应用开发。 阅读详情

相关推荐

【树莓派4B】八、树莓派软路由,Ubuntu18.04配置路由转发

我的目的是通过把树莓派做成一个软路由,相当于一个智能路由器。 材料 树莓派4B,操作系统其实可以是其他的Linux版本。以为4B自带无线网卡,就用自带无线网卡作为路由出口。 大概思路 具体步骤 配置两个网卡的IP sudo vim /etc/network/interface 这里设置静态IP,也可以动态获取。 #Local loopback auto lo iface lo inet loopback #Ethernet0 auto eth0 iface eth0 inet static addr

林愿留的博客 10万+

C++多态详解

在继承中构成多态有两个条件:1.必须通过基类的指针和引用调用虚函数 2.被调用的函数必须是虚函数 ,且派生类必须对基类的虚函数进行重写 多态调用时在运行时在虚函数表找函数的地址,进行调用,所以指向父类调的是父类的虚函数,指向子类调用的是子类的虚函数而普通调用时是在编译时,通过调用者类型确定函数地址

liuty0125的博客 1544

RYU+Mininet的SDN架构-设计校园网络(一)

现有一个中学,需要设计一个中小型网络满足学校的网络需求。学校有教学区,实验室区域和服务器区域。教学区为了满足接入的灵活性和信号强度要求,需要满足设计WIFI满足日常教室和同学需求,接入上限为200人。实验室区域需要有一台教师主机方便管理实验室其余电脑,并且教师主机可以访问学校服务器,方便为同学们实验室授课。学校服务器区域设有学校相关重要文件和学校网页相关内容。最后学校还会接入互联网。

weixin_53284122的博客 8036

什么是多态?如何实现?只看这一篇就够了

1. 多态的概念 1.1 概念 多态的概念:通俗来说,就是多种形态,具体点就是去完成某个行为,当不同的对象去完成时会产生出不同的状态。 2. 多态的定义及实现 2.1多态的构成条件 多态是在不同继承关系的类对象,去调用同一函数,产生了不同的行为。 那么在继承中要构成多态还有两个条件: 必须通过基类的指针或者引用调用虚函数 被调用的函数必须是虚函数,且派生类必须对基类的虚函数进行重写 2.2 ...

海盗船长y的博客 13万+

主成分分析(PCA)和局部线性嵌入(LEE)原理详解

从KNN谈“维度灾难”,介绍线性降维PCA和局部线性嵌入LLE 这两种降维方法的原理

superzzx0920的博客 5617

FPGA原型验证(七):如何选择、搭建原型验证平台?

本篇概要::讨论了在项目初期选择目标FPGA平台的重要性,包括自制板卡与购买现成板卡之间的决策。主要是为那些希望建立基于FPGA的原型平台的工程师和设计师提供了深入的技术细节和决策指导,无论是选择自制还是购买现成的解决方案。

叫好与叫座虽然不是对立面,但想在同一个作品中达到双重效果很难。 947

什么是多态?一文彻底搞懂!

多态包括编译时多态和运行时多态。编译时多态,即静态绑定,通常通过方法重载实现。运行时多态则是在代码运行时确定具体调用的方法。从Java的角度看,严格意义上的多态需要满足三个条件:继承、方法覆盖和父类引用子类对象。Java完全符合这些要求,实现了严格意义上的多态。尽管Go语言、Python和JavaScript不完全符合严格意义上的多态,它们仍能够实现多态效果。多态的核心在于动态确定运行的方法,从而使代码更加灵活、易于维护和扩展。Go语言虽然没有继承和方法重载,但仍能实现多态效果。

5076

激光雷达与相机时间戳同步:原理、触发方案与工程实现

目录一、引言:时间不同步,多传感器融合必出问题二、核心原理:相机成像机制与触发模式(同步的基础)2.1 相机成像的两个核心阶段:曝光与读出(1)非交叠曝光(2)交叠曝光2.2 相机触发模式:内触发 vs 外触发(1)内触发(2)外触发2.3 关键信号:Strobe信号与预输出(同步的核心技巧)三、三种主流时间戳同步方案(工程落地首选)3.1 方案一:统一硬触发(精度最高,高端场景首选)核心原理核心配置要点优缺点适用场景3.2 方案二:软触发+硬触发(Strobe预输出,车载量产首选)核心原理核心配置要点优缺

getusushu的博客 206

C++进阶:(二)多态的深度解析

本文全面解析C++多态特性,从概念、实现到底层原理。多态分为编译时多态(函数重载/模板)和运行时多态(虚函数重写),后者需满足继承、虚函数重写和基类指针/引用调用三大条件。深入讲解虚函数表、动态绑定机制,剖析协变、析构函数重写、override/final等进阶特性,并通过计算器案例演示多态应用。最后解析面试高频考点,包括虚函数表存储位置、多态性能开销等。掌握多态的核心原理,能写出更灵活、可扩展的面向对象代码。

2301_79248256的博客 2049

嵌入式软件工程师面试题目整理(一)

文章目录嵌入式软件工程师面试题目整理(一)Arm有多少32位寄存器?Arm2440和6410有什么区别CPU,MPU,MCU,SOC,SOPC联系与差别上拉&下拉&高阻态串口协议讲一讲RS232和RS485通讯接口有什么区别IIC时序图画一下,IIC有哪些状态,给一个字节,将它发送出去。IIC有什么注意事项?有没有用I/O模拟IIC,如果有需要注意什么?为什么2440的内存起始地址是3后面7个0呢?为什么6410的内存起始地址是5后面7个0呢?内存管理有什么看法?(MMU)锁有哪些?有什么注

嵌入式与Linux那些事的博客 7883

PyTorch实战(2)——使用PyTorch构建神经网络

在本节中,我们使用 PyTorch 在简单数据集上构建了一个神经网络,训练神经网络来映射输入和输出,并通过执行反向传播来更新权重值以最小化损失值,并利用 Sequential 类简化网络构建过程;介绍了获取网络中间值的常用方法,以及如何使用 save、load 方法保存和加载模型,以避免再次训练模型。

盼小辉丶的博客 1万+

多态的简单理解

多态就是一个物体的多种形态。 自然界中的事物比如:猫、狗、大象它们都会跑,但是跑的方式不一样。再比如:鸟、昆虫、飞机 都会飞,但是飞的方式不一样。这就是多态。 在Java中,多态就是对于同一个命令(方法),有不同的执行方式(内容)。 前提: 1. 有继承或者实现 2. 有方法的重写(如果没有方法重写,那么多态的意义就没有了) 3. 父类的引用指向子类的对象 Fu f = new Zi(); 等号的左边:父类的引用f,理解为一个指针指向子类对象 等号的右边:子类的对象new Zi(); 探究的

qq_45279172的博客 611

C#操作MySQL从入门到精通(1)——安装MySQL数据库

我们使用C#操作MySQL数据库第一步要做的就是安装MySQL数据库,本文就是详细讲解如何安装MySQL数据库。

qq_34059233的博客 965

面向对象——多态

1. 多态概念        多态是面向对象程序设计(OOP)的一个重要特征,指同一个实体同时具有多种形式,即同一个对象,在不同时刻,代表的对象不一样,指的是对象的多种形态。        可以把不同的子类对象都当作父类来看,进而屏蔽不同子类对象之间的差异,写出通用的代码,做出通用的编程,统一调用标准。 多态的主要用途 1、提高程序的可扩展性; 2、降低系统耦合度; 3

杨思默 3133

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

什么是多态?面向对象中对多态的理解

多态(Polymorphism)是面向对象编程(OOP)中的一个核心概念,它允许对象以多种形式出现。多态性使得同一个接口可以用于不同的数据类型,从而使得代码更加灵活和可扩展。简单来说,多态就是一个接口,一个类,一个抽象类,一个类里面的方法,不同类的同一个方法,都可以有多种实现,这个在面向对象里面,就对应着继承、重载、重写等具体的方式。灵活性:多态性允许同一个接口用于不同的对象,从而使得代码更加灵活。可扩展性:可以在不修改现有代码的情况下,通过添加新的类来扩展程序的功能。

fefdfg的博客 1733

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

面向对象——多态详解

多态(Polymorphism)属于面向对象的三大特征之一,它的前提是封装形成独立体,独立体之间存在继承关系,从而形成多态机制。多态是同一个行为具有多个不同表现形式的能力。多态就是“同一个行为”发生在“不同对象上”会产生不同的效果。多种形态,多种状态,编译和运行有两个不同的状态编译期叫做静态绑定运行期叫做动态绑定现在我们再来回顾面向对象的三大特征:封装、基础、多态他们之间的关系是一环扣一环首先得封装成一个整体才有了继承的概念有了继承关系才有了多态的实现 ......

shouyeren_st的博客 1635

面向对象—多态

多态

qq_44346427的博客 3844

【多态】面向对象之多态实例代码

【多态】面向对象之多态实例 对象: 主人 行为:喂养宠物 宠物(父类) 行为:吃XXX 猫(子类) 行为:吃鱼 狗(子类) 行为:吃骨头 实例代码: 1.无多态实例代码 public class Master{ public void feed( Cat cat){ cat.eat(); } public void feed(Dog dog){ dog.eat();...

qq_40284440的博客 578

面向对象的三大特征之一多态

1. 什么是多态 多态性是面向对象编程的又一个重要特征,它是指在父类中定义的属性和方法被子类继承之后,可以具有不同的数据类型或表现出不同的行为,这使得同一个属性或方法在父类及其各个子类中具有不同的含义。 对面向对象来说,多态分为编译时多态和运行时多态。其中编译时多态是静态的,主要是指方法的重载,它是根据参数列表的不同来区分不同的方法。通过编译之后会变成两个不同的方法,在运行时谈不上多态。而运行时多态是动态的,它是通过动态绑定来实现的,也就是大家通常所说的多态性。 简单的说就是 在通过父类来获取他名下继承

qq_28629389的博客 1819

面向对象设计领域中的参数多态,包含多态,过载多态和强制多态

在面向对象设计中,多态性是一个重要的概念,它允许我们以一种统一的方式处理不同类型的对象,并根据对象的实际类型来执行相应的行为。通过将具体的对象看作是其父类或接口的实例,并在方法调用时根据实际的对象类型来确定具体的执行逻辑,我们可以以一种统一的方式处理不同类型的对象。- 当方法需要操作的对象类型不确定时,可以使用多态来接受不同类型的对象,减少代码的重复。使用场景: - 当需要执行类似的操作,但操作的参数类型或个数可能不同时,可以使用过载多态来定义多个方法,使得代码更清晰、简洁,并提高代码的可读性。

辣香牛肉面的博客 1468

面向对象的多态

多种形态,总的来说:同一件事情,发生在不同对象身上,就会产生不同的结果。1.2.3.完成以上3部分会发生动态绑定(是多态最基础的)实际就是创建一个子类对象,将其当成父类对象来使用。

forwkard__的博客 1080

面向对象-多态性

 面向对象的软件开发语言具有三个重要的特点分别为封装性、继承性、多态性。封装性即意味着对象封装其内部的数据,使其对外不可见,以保证数据的安全性。继承性是代码复用的一个很好的解决方案,但是继承关系是编译器在编译阶段就为所有的对象决定的,因而在软件工程过程中,继承性太过死板,存在很大的局限性。而多态性,它是将多种不同的特殊行为进行抽象的一种能力,通过结合继承性,多态性很好地解决了OO遇到的很多麻烦

闪亮每一天 3869

面向对象理解——多态

何为多态

LYQ 1万+
上一篇: ORA-01722:invalid number-解决GAT项目中车辆维修Bug(续)
下一篇: 面向对象-final关键字
ZHOU_VIP
博客等级 码龄11年 1万+粉丝 1779原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ZHOU_VIP

您的鼓励将是我创作最大的动力!

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值