多态

什么是多态?为什么要使用多态?什么时候用多态?多态是如何实现的?使用多态有什么好处?   在学习《大话设计模式》的时候经常会遇到多态,但什么是多态?为什么要使用多态?什么时候用多塔?多态是如何实现的?使用多态有什么好处?我们将根据以上五个问题展开激烈的讨论。 什么是多态?   多态,顾名思义指“多种形态”。多态表示不同的对象可以执行相同的动作,但要通过它们自己的实现代码来执行。 例:猪、狗、猫都属于动物类,我们将动物类作为父类,猪“哼哼叫”,狗“汪汪叫”,猫“喵喵叫”,猪、狗、猫三... 阅读详情

带着问题探索多态

package cn.partner4java.test;

public class A {
	public A() {
		System.out.println("Constructor A");
	}
}


package cn.partner4java.test;

public class B extends A {
	public B() {
		System.out.println("Constructor B");
	}
	
	public static void main(String[] args) {
		A a = new A();
		B b = new B();
//		后台打印:
//		Constructor A
//		Constructor A
//		Constructor B

	}
}


package cn.partner4java.test;

/**
 * 如果把构造器当做方法,那么B就是重写Override了A的构造器,那么就应该少答应一个“Constructor A”。
 * 但是构造器Constructor是否可被override? 
 * 构造器Constructor不能被继承,因此不能重写Override,但可以被重载Overload。
 * 具体为什么,我们将进行学习。
 * @author partner4java
 *
 */
public class B extends A {
	public B() {
		System.out.println("Constructor B");
	}
	
	public static void main(String[] args) {
		A a = new A();
		B b = new B();
//		后台打印:
//		Constructor A
//		Constructor A
//		Constructor B

	}
}

如果把构造器当做方法,那么B就是重写Override了A的构造器,那么就应该少答应一个“Constructor A”。
但是构造器Constructor是否可被override? 
构造器Constructor不能被继承,因此不能重写Override,但可以被重载Overload。
具体为什么,我们将进行学习。




在面向对象的程序设计语言中,多态是继数据抽象和继承之后的第三个基本特性。


多态的作用则是消除类型之间的耦合关系。


多态方法调用允许一种类型表现出与其他相似类型之间的区别,只要他们都是从同一个基类导出而来的。这种区别是根绝方法行为的区别而表现出来的,虽然这些方法都可以同一个基类来调用。


多态(也成做动态绑定、后期绑定或运行时绑定)。



--------------------------------------------------------------------------------------------------------

再论向上转型

对象既可以作为他自己本身的类型使用,也可以作为他的基类型使用。
把对某个对象的引用视为对其基类型的引用的做法成为:向上转型。


向上转型:

package cn.partner4java.problem;

public enum Note {
	MIDDLE_C,C_SHARP,B_FLAT;
}


package cn.partner4java.problem;

public class Instrument {
	public void play(Note note){
		System.out.println("Instrument play");
	}
}


package cn.partner4java.problem;

public class Wind extends Instrument {
	@Override
	public void play(Note note) {
		System.out.println("Wind play " + note);
	}
}

package cn.partner4java.problem;

public class Music {
	public static void tune(Instrument instrument){
		instrument.play(Note.MIDDLE_C);
	}
	
	public static void main(String[] args) {
		Wind wind = new Wind();
		tune(wind);
		
//		后台打印:
//		Wind play MIDDLE_C
	}

}

-----------------------------------------------------------------------------------

转机

1、方法调用绑定
将一个方法调用同一个方法主体关联起来被称作绑定。
若在程序执行之前绑定叫做前期绑定。


后期绑定,根绝运行时的对象类型进行绑定,也叫动态绑定或运行绑定。不管怎么样都需要在对象中安置某种“类型信息”。


Java中除了static方法和final方法(private方法属于final方法)之外,其他所有的方法都是后期绑定。


Demo:

package cn.partner4java.problem;

public class Instrument {
	public static void play(Note note){
		System.out.println("Instrument play");
	}
}


package cn.partner4java.problem;

public class Wind extends Instrument {
	public static void play(Note note) {
		System.out.println("Wind play " + note);
	}
}


package cn.partner4java.problem;

public class Music {
	public static void tune(Instrument instrument){
		instrument.play(Note.MIDDLE_C);
	}
	
	public static void main(String[] args) {
		Wind wind = new Wind();
		tune(wind);
		
//		后台打印:
//		Instrument play
	}

}

final比较重要的一定就是可以“关闭”动态绑定,告诉编译器不需要对其进行动态绑定。这样,编译器就可以为final方法调用生成更有效的代码。但是,通常对性能不会有什么改观。






2、产生正确的行为
经典的“几何形状”的例子。

package cn.partner4java.shape;

/**
 * 基类Shape,几何形状
 * @author partner4java
 *
 */
public class Shape {
	public void draw() {
		
	}
	
	public void erase() {

	}
}


package cn.partner4java.shape;

/**
 * 圆“是一种几何形状”
 * @author partner4java
 *
 */
public class Circle extends Shape {
	@Override
	public void draw() {
		System.out.println("Circle.draw()");
	}
	@Override
	public void erase() {
		System.out.println("Circle.erase");
	}
}

package cn.partner4java.shape;

/**
 * 方“是一种几何形状”
 * @author partner4java
 *
 */
public class Square extends Shape {
	@Override
	public void draw() {
		System.out.println("Square.draw()");
	}
	@Override
	public void erase() {
		System.out.println("Square.erase");
	}
}

package cn.partner4java.shape;

import java.util.Random;

public class RandomShapeGenerator {
	private Random random = new Random(47);
	public Shape next(){
		switch (random.nextInt(2)) {
			default:
			case 0: return new Circle();
			case 1: return new Square();
		}
	}
}





3、可扩展性
多态是一项让程序员“将改变的事务与未变的事务分离开来”的重要技术。






4、缺陷:“覆盖”私有方法
只要非private的方法才可以被覆盖;但是还需要密切注意覆盖private方法的现象,这时虽然编译器不会报错,但是也不会按照我们所希望的来执行。确切的说,在导出类中,对于基类的private方法,最好采用不同的名字。






5、缺陷:域与静态方法

package cn.partner4java.field;

public class Super {
	public int field = 0;

	public int getField() {
		return field;
	}
	
}


package cn.partner4java.field;

public class Sub extends Super {
	public int field = 1;

	public int getField() {
		return field;
	}
	
	public int getSuperField(){
		return super.field;
	}
	
}


package cn.partner4java.field;
/**
 * 当Sub对象转型为Super引用时,任何域访问操作都让由编译器解析,因此不是多态的。
 * @author partner4java
 *
 */
public class FieldAccess {

	public static void main(String[] args) {
		Super sup = new Sub();
		System.out.println("sup.field = " + sup.field + 
				" ,sup.getField = " + sup.getField());
		
		Sub sub = new Sub();
		System.out.println("sub,field = " + sub.field + 
				" ,sub.getField = " + sub.getField() + ",sub.getSuperField = " + 
				sub.getSuperField());
		
//		后台打印:
//		sup.field = 0 ,sup.getField = 1
//		sub,field = 1 ,sub.getField = 1,sub.getSuperField = 0
	}

}





如果某个方法是静态的,他的行为就不具有多态性:

package cn.partner4java.staticmethod;

public class StaticMethodSuper {
	public static void staticMehtod(){
		System.out.println("StaticMethodSuper.staticMehtod");
	}
	
	public void method(){
		System.out.println("StaticMethodSuper.method");
	}
}

package cn.partner4java.staticmethod;

/**
 * 如果某个方法是静态的,他的行为就不具有多态性:
 * @author partner4java
 *
 */
public class StaticMethod extends StaticMethodSuper {
	
	public static void staticMehtod(){
		System.out.println("StaticMethod.staticMehtod");
	}
	
	public void method(){
		System.out.println("StaticMethod.method");
	}
	
	public static void main(String[] args) {
		StaticMethodSuper method = new StaticMethod();
		method.staticMehtod();
		method.method();
//		后台打印:
//		StaticMethodSuper.staticMehtod
//		StaticMethod.method

	}
}


-------------------------------------------------------------------------------

构造器和多态

构造器并不具有多态性(他们实际上是static方法,只不过该static声明是隐式的)




1、构造器的调用顺序
基类的构造器总是导出类的构造过程中被调用,而且按照继承层次逐渐向上连接,以便基类的每个构造都能得到调用。
这样做是有意义的,因为构造器具有一项特殊任务:检查对象是否被正确的构造。
导出类只能访问它自己的成员,不能访问基类的成员(基类成员通常是private类型)。
只要基类的构造器才具有恰当的知识和权限来对自己的元素进行初始化。
因此,必须另所以构造器都得到调用,否则就不可能正确构造完整对象。
这正是编译器为什么要强制每个导出类部分都必须调用构造器的原因。
在导出来的构造器主题中,如果没有明确指定调用某个基类构造器,他就会默默调用默认构造器。
如果不存在默认构造器,编译器就会报错。

package cn.partner4java.test;

public class A {
	public A() {
		System.out.println("Constructor A");
	}
	
	public A(String name){
		System.out.println("Constructor A " + name);
	}
}

package cn.partner4java.test;

/**
 * 如果把构造器当做方法,那么B就是重写Override了A的构造器,那么就应该少答应一个“Constructor A”。
 * 但是构造器Constructor是否可被override? 
 * 构造器Constructor不能被继承,因此不能重写Override,但可以被重载Overload。
 * @author partner4java
 *
 */
public class B extends A {
	public B() {
		System.out.println("Constructor B");
	}
	
	public B(String name){
		System.out.println("Constructor B " + name);
	}
	public static void main(String[] args) {
		A a = new A();
		System.out.println("-----");
		A a2 = new B();
		System.out.println("-----------");
		B b = new B();
		System.out.println("-----");
		A a3 = new B("Hello");
		System.out.println("-----------");
		B b2 = new B("Hello");
		
		
//		后台打印:
//		Constructor A
//		-----
//		Constructor A
//		Constructor B
//		-----------
//		Constructor A
//		Constructor B
//		-----
//		Constructor A
//		Constructor B Hello
//		-----------
//		Constructor A
//		Constructor B Hello

	}
}



上面的打印还表明了一个观点,父类或者说基类也就是A必须有无参的构造器或者默认构造器(如果没有默认构造器,那么子类的构造器就需要指明需要调用父类的哪个构造器,不然,会默认子类构造器第一行加一个父类无参的构造器,但是父类不存在的话,就会出现错误--Implicit super constructor A() is undefined. Must explicitly invoke another constructor)。








调用构造器遵循的顺序:
1、调用基类的构造器。这个步骤会不断的反复递归下去,首先是构造这种层次结构的根,然后是下一层导出类,等等,直至最底层的导出类。
2、按声明顺序调用成员的初始化方法。
3、调用导出类构造器的主体。
demo如下:

package cn.partner4java.order;

/**
 * 膳食
 * @author partner4java
 *
 */
public class Meal {
	public Meal() {
		System.out.println("Meal()");
	}
}

package cn.partner4java.order;

/**
 * 面包
 * @author partner4java
 *
 */
public class Bread {
	public Bread() {
		System.out.println("Bread()");
	}
}

package cn.partner4java.order;

/**
 * 奶酪
 * @author partner4java
 *
 */
public class Cheese {
	public Cheese() {
		System.out.println("Cheese()");
	}
}


package cn.partner4java.order;

/**
 * 生菜
 * @author partner4java
 *
 */
public class Lettuce {
	public Lettuce() {
		System.out.println("Lettuce()");
	}
}


package cn.partner4java.order;

/**
 * 午餐
 * @author partner4java
 *
 */
public class Lunch extends Meal {
	public Lunch() {
		System.out.println("Lunch()");
	}
}


package cn.partner4java.order;

/**
 * 便携午餐
 * @author partner4java
 *
 */
public class PortableLunch extends Lunch {
	public PortableLunch() {
		System.out.println("PortableLunch()");
	}
}


package cn.partner4java.order;

/**
 * 三明治
 * @author partner4java
 *
 */
public class Sandwich extends PortableLunch {
	private Bread bread = new Bread();
	private Cheese cheese = new Cheese();
	private Lettuce lettuce = new Lettuce();
	public Sandwich() {
		System.out.println("Sandwich()");
	}
	public static void main(String[] args) {
		new Sandwich();
	}
}
//后台打印:
//Meal()
//Lunch()
//PortableLunch()
//Bread()
//Cheese()
//Lettuce()
//Sandwich()













2、继承和清理
通过组合和继承方法来创建新类时,永远不必担心对象的清理问题,子对象通常都会留给垃圾回收器处理。如果确实遇到清理的问题,那么必须用心为新类创建dispose()方法。
并且由于继承的缘故,如果我们有其他作为垃圾回收一部分的特殊清理工作,就必须在导出类中覆盖dispose()方法。
当覆盖被继承类的dispose()方法时,务必记住调用基类版本dispose();否则,基类的清理动作就不会发生。










3、构造器内部的多态方法的行为

package cn.partner4java.inner;

public class Glyph {
	void draw(){
		System.out.println("Glyph.draw()");
	}
	public Glyph() {
		System.out.println("Glyph before draw()");
		draw();
		System.out.println("Glyph after draw()");
	}
}

package cn.partner4java.inner;

public class RoundGlyph extends Glyph {
	private int radius = 1;
	public RoundGlyph(int r) {
		radius = r;
		System.out.println("RoundGlyph ,radius = " + radius);
	}
	void draw(){
		System.out.println("RoundGlyph.draw(),radius = " + radius);
	}
	public static void main(String[] args) {
		new RoundGlyph(5);
	}
}
//后台打印:
//Glyph before draw()
//RoundGlyph.draw(),radius = 0
//Glyph after draw()
//RoundGlyph ,radius = 5





初始化的实际过程是:
1、在其他任务发生之前,将分配给对象的存储空间初始化二进制的零。
2、如前所述那样调用构造器。此时,调用被覆盖后的draw()方法(要在调用RoundGlyph构造器之前调用),由于步骤1的缘故,我们此时会发现radius的值为0。
3、按照声明的顺序调用成员的初始化方法。
4、调用导出类的构造器主体。






因此,编写构造器有一条有效的准则:“就尽可能简单的方法使对象进入正常状态;如果可以的话,避免其他方法”。
在构造器内唯一能够安全调用的那些方法是基类中的final方法(也适用于private方法,他们自动属于final方法)。
这些方法不能被覆盖,因此也就不会出现上面这种情况。


-----------------------------------------------------------------------------------------

协变返回类型

package cn.partner4java.change;

public class Grain {
	@Override
	public String toString() {
		return "Grain";
	}
}

package cn.partner4java.change;

public class Wheat extends Grain {
	@Override
	public String toString() {
		return "Wheat";
	}
}

package cn.partner4java.change;

public class Mill {
	Grain process(){
		return new Grain();
	}
}

package cn.partner4java.change;

public class WheatMill extends Mill{
	Wheat process(){
		return new Wheat();
	}
}

package cn.partner4java.change;

/**
 * Java SE5与Java较早版本之间的主要差异就是:
 * 较早的版本强制process()的覆盖版本必须返回Grain,而不能返回Wheat,
 * 尽管Wheat是从Grain导出来的,因而也应该是一种合法的返回类型。
 * 协变返回类型允许返回更具体的Wheat类型。
 * @author partner4java
 *
 */
public class CovariantReturn {
	public static void main(String[] args) {
		Mill mill = new Mill();
		Grain grain = mill.process();
		System.out.println(grain);
		
		mill = new WheatMill();
		grain = mill.process();
		System.out.println(grain);
	}
}
//后台打印:
//Grain
//Wheat

---------------------------------------------------------------------

用继承进行设计


准则:用继承表达行为间的差异,并用字段表达状态上的变化。




向上转型的安全和向下转型的类型转换异常。

LIN总线从入门到精通:低成本汽车通信协议原理与实战 在汽车电子和嵌入式系统中,串行通信协议是实现分布式控制的关键技术。其中,LIN(Local Interconnect Network)总线作为一种专为低成本应用设计的单主多从网络协议,其核心原理在于通过简化的“领导-汇报”通信模式,在满足车身控制、传感器数据采集等场景需求的同时,将硬件与布线成本降至最低。LIN总线采用标准化的帧结构,包含间隔场、同步场和受保护标识符场,并依赖调度表来管理通信时序,确保了网络的确定性与可靠性。其技术价值在于为车窗、座椅、灯光等非安全关键系统提供了高性价比的解决方案,是构建分层 阅读详情

相关推荐

软件项目质量管理

识别项目中涉及质量管理的不同角色,如项目经理、质量经理、测试人员等,明确每个角色的职责和任务,包括负责哪些质量管理活动和决策。1、编制软件项目的质量管理计划,包括确定项目的质量标准和要求,以及制定质量控制和质量保证策略等。2、编制软件项目的质量管理计划,包括确定项目的质量标准和要求,以及制定质量控制和质量保证策略等。测试用例表是质量控制过程中的关键工具,确保所有功能和场景都被验证,减少项目中的缺陷。1、理解项目质量管理的基本过程,包括质量计划、质量保证、质量控制和质量改进;明确质量管理活动中的角色和职责。

weixin_51996255的博客 1261

什么是多态

目录 什么是多态 多态的特点 多态存在的三个必要条件 多态时成员变量、静态方法和非静态方法的特点 什么是多态 多态就是一个对象变量可以指向多种实际类型的现象,同一个事件发生在不同的对象上会产生不同的结果。 多态的特点 好处:消除类型之间的耦合关系 弊端:不能用子类方法,可用转型的方法解决 转型: ·向上转型:【自动】父类 父类对象 = 子类实例; Fu f...

weixin_43827227的博客 1万+

JavaSpringBoot + VUE 相关开发环境配置合集

1.Java环境-JDK安装 参照:Java基础1-环境篇:JDK安装与环境变量配置 Java基础1-环境篇:JDK安装与环境变量配置_第一段代码的博客-优快云博客_jdk 2.Web服务器-Tomcat安装 原创Java服务器Tomcat安装和配置 3.Maven(后面为了项目兼容性,使用了3.0.5版本) 原创Maven安装和配置(Maven3.0.5) 4.nginx 原创nginx轻量级Web服务器安装和配置 5 数据库mysql 原创数据库Mysql安装和配置 ...

第一段代码的博客 3164

Java中编译时多态与运行时多态

文章目录1. 什么是多态2. 编译时多态3. 运行时多态总结Reference 口诀:成员变量,静态方法看左边;非静态方法:编译看左边,运行看右边 当父类变量引用子类对象时(Father f = new Son();),在这个引用变量f指向的对象中,它的成员变量和静态方法与父类是一致的,他的非静态方法,在编译时是与父类一致的,运行时却与子类一致(发生了复写) 1. 什么是多态 多态是指允许不同子类型的对象对同一行为作出不同的响应。例如在生活中,比如跑的动作,小猫、小狗和大象,跑起来是不一样的。再比如飞

xylitolz的博客 9383

SLG项目开发经验二_大地图设计与实现

本文深入探讨了SLG游戏大地图设计与实现的关键技术,包括网格化业务框架、AOI系统优化、边界处理方案以及行军系统实现。通过Unity引擎的实践案例,详细解析了大地图性能优化的核心策略,如分块加载、GPU Instancing和差异同步协议,为SLG项目开发提供宝贵经验。

weixin_29001419的博客 226

unity制作交互视频/互动视频

unity制作交互视频/互动视频 思路 1.先让unity播放视频 2. 视频播放结束后,视频暂停,按钮出现 3.按钮跳转下一个视频 视频播放 先创建UI-Raw Iamge 在Raw Iamge 挂载组件 Video Player 接着挂载视频播放的脚本 using UnityEngine; using UnityEngine.UI; using UnityEngine.Video; publi...

weixin_45588911的博客 8429

多态 静态多态 动态多态

抽象类提供一个框架,强制子类实现特定的功能。

weixin_43490759的博客 2936

Claude Code设置中文输出指南

Claude Code 的语言配置其实并不复杂,只要做好全局的默认设置,再加上一些小的提醒技巧,就能完全避免突然切换英文的问题,让你全程用中文流畅地和 AI 助手协作,不用再被语言问题打断工作节奏,真正提升开发效率。

篮球界最会写bug的人;程序猿中打球最菜的人。 2255

C++多态——静态多态与动态多态

多态:顾名思义,多态就是多种形态,也就是对不同对象发送同一个消息,不同对象会做出不同的响应。并且多态分为静态多态和动态多态。静态多态就是在系统编译期间就可以确定程序执行到这里将要执行哪个函数,例如:函数的重载,对象名加点操作符执行成员函数等,都是静态多态,其中,重载是在形成符号表的时候,对函数名做了区分,从而确定了程序执行到这里将要执行哪个函数,对象名加点操作符执行成员函数是通过this指针来调用的

stay_the_course的博客 1万+

自动驾驶---Planning模块详细介绍(以Apollo为例)

主要介绍高速场景下Planning模块,至于低速的泊车场景对比高速场景或者城区场景有比较大的差距(后面也会介绍泊车场景),本篇Planning介绍主要包括三大子模块Routing,Behavioural Planning以及Motion Planining,并且对比较重要的Decider和Optimizer都做了通俗化的说明供大家思考,以便于后续理解更深入的内容,后面有时间会再开一些篇幅对这些模块进行更加深入的讲解。

智能汽车人的博客 2089

C++ Qt6 QtQuick/QML入门进阶与项目实战视频教程

C++ Qt这些年在PC客户端、嵌入式、汽车座舱仪表等领域应用很广泛,例如剪映专业版、微信4.0、亿图脑图、Steam、美图秀秀、腾讯会议、钉钉(部分模块)等都是使用C++ QWidget/QML开发。特别是QML这种声明式UI开发更加快捷,QML的界面开发效率相对于QWidget更快速,界面效果更好,QtQuick/QML在Qt6版本也逐渐完善了,使用QML进行客户端开发是个不错的选择。

琅嬛福地 4494

java 多态的应用——多态数组和多态参数详解

java 多态的应用——多态参数和多态数组内容分享,本篇博文为java 面向对象三大特性——多态篇的补充。

优快云 / 稀土掘金/ B站 / GitHub: Cyan_RA9 3839

Scrapy爬虫之热门网站数据爬取--------第2关

第2关:小说网站玄幻分类第一页小说爬取 任务描述 本关任务:爬目标网页的3本小说保存到本地MySQL数据库,目标网页为全书网玄幻分类首页。 注:考虑到单机(非分布式)爬虫的爬取时间和测试平台的压力,我们不爬更多页数的小说了,可以作为课下作业自己完善。 xpath匹配:循环获取相同标签下的内容 通过网页分析,我们在获取小说的章节名时,发现他们都在标签<DIV class="clearfix dirconone">下的li的a中: 这时,我们可以先把其中所有的li标签先获取到: titles = r

weixin_44949187的博客 2838

C++ 多态全解析:静态多态与动态多态详解

本文将系统梳理多态的定义、官方权威解释、静态与动态多态的区别、典型代码与注意事项,帮助你彻底搞懂C++多态。

Darker的博客 2328

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

多态性

多态性 多态性的概念 派生一个类的原因并非总是为了继承或添加新成员,有时是为了重新定义基类的成员,使基类成员“获得新生” 面向对象程序设计的真正力量不仅仅是继承,而是允许派生类对象像基类对象一样处理,其核心机制就是多态和动态联编 多态是指同样的消息被不同类型的对象接收时导致不同的行为。所谓消息是指对类成员函数的调用,不同的行为是指不同的实现,也就是调用了不同的函数 从广义上说,多态性是指一段程序能够处理多种类型对象的能力 在C++中,这种多态性可以通过重载多态(函数和运算符重载),强制多态(类型强制转换),

weixin_51958878的博客 5264

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

Java多态:多态多态,多种形态

Java多态:灵活处理对象的行为展现机制

子夜的个人博客 1746

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

参数多态、包含多态、过载多态和强制多态

多态分为两种:通用的多态和特定的多态。两者的区别是前者对工作的类型不加限制,允许对不同类型的值执行相同的代码;后者只对有限数量的类型有效,而且对不同类型的值可能要执行不同的代码。     通用多态又分为参数多态(parametric)和包含多态(Inclusion Polymorphism);特定多态分为过载多态(overloading)和强制多态(coercion)。     强制多态(

飞老虎 1万+

静态多态和动态多态的区别

#include <iostream> using namespace std; class A { public: virtual void function() { cout << "I am A" << endl; } }; class B :public A { public: void function() { cout << "I used to be A but now I am B" << endl; } void fun

weixin_45027171的博客 6919

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

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

辣香牛肉面的博客 1468

多态性之编译期多态和运行期多态(C++版)

编译期多态和运行期多态(C++版)     C++中最为经典的就是多态性,多态性充分体现了面向对象的思想,并且是C++与C的最大区别之一。多态性分为编译期多态和运行期多态,也称为静态多态和动态多态,有些人也称其为编译时多态和运行时多态,不管什么称呼,万变不离其宗,一个是编译期的静态的多态,一个是运行期的动态的多态,那么它们在C++中分别体现在哪里呢?又有什么区别呢?下面将详细介绍(重点是

君临天下的博客 7244

C++ 多态详解:从静态多态到动态多态

从字面上理解,多态就是“多种形态”。在程序设计里,它指的是:使用,却可以对做出不同的具体行为。virtual。

2301_80345648的博客 1191

Java 多态以及多态的实现

编译环境 windows 10 JDK 1.8 eclipse 目录    一、多态的基本概念    二、继承    三、多态的实现    四、多态存在的三个必要条件    五、重写    六、抽象类和抽象方法    七、接口    八、向上转型实现多态    九、多态的优缺点 前言   多态,多态,多态到底是一个什么样的定义呢,充满着好奇心,决定去研究一番。 多态(Polymorphism)的基本概念   多态意味着父类的变量可以指向子类对象。多态是同一个行为具有多个不同表现形式或形态的能力,就

Karbob 2449

深入剖析多态,什么是多态?多态有什么用?

前言: 今天我准备探讨一下多态的终极奥义,Java也学习了两年了,但是对于多态一直不是很理解,上周刚刚来到青软实训基地,才有了时间深入学习这些熟知用法而不知底层的知识。 花了一天时间来了解多态存在的意义。本篇博客让我们从一个完全不懂得状态一步步了解什么是多态,深入掌握多态的概念。 什么是多态? 让我们看看百度是怎么定义多态的,话不多说,上图! 望文生义,第一眼看到多态,感觉就是多种...

Bean冷的心的博客 932

多态以及多态底层的实现原理

1.必须是基类的指针或者引用去调用虚函数2.虚函数必须完成了重写或者覆盖因为我们前面所将的切片的类型兼容转换,只有基类的指针或者引用才能即指向基类对象又指向派生类对象.虚函数的重写或者覆盖所指的是它的实现重写,这样基类和派生类才能有不同的函数.才能实现多态.class Apublic:public:int main()ptr1->a();ptr2->a();return 0;以上就是多态的实现.

20 • backend dev • building things that just work • learning systems & low level stuff • love video games 944

编译时多态和运行时多态

编译时多态和运行时多态 多态分为两种情况:编译时多态和运行时多态。如果在编译时能够确定执行多态方法称为编译时多态,否则称为运行时多态。 一、编译时多态 方法重载都是编译时多态。根据实际参数的数据类型、个数和次序,Java在编译时能够确定执行重载方法。 方法覆盖表现出两种多态性,当对象引用本类实例时,为编译时多态,否则为运行时多态。例如,以下声明p、m引用本类实例,调用toString()方法是编译时多态。 public class Test { public static void

twx31420的博客 4997

C++多态:静态多态vs动态多态

多态(Polymorphism)作为面向对象编程的三大核心特性之一,是构建灵活、可扩展软件系统的关键所在。在C++中,多态的实现主要分为静态多态(Static Polymorphism)和动态多态(Dynamic Polymorphism)两种形式,它们以不同的方式实现了"一个接口,多种实现"的核心思想。在这一篇博客里我有详细介绍(

ye_yumo的博客 1173
上一篇: 第3章 垃圾收集器与内存分配策略--《深入理解 Java 虚拟机》笔记
下一篇: 初始化与清理
partner4java
博客等级 码龄17年 481粉丝 183原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值