精华内容
下载资源
问答
  • 简述多态的作用
    千次阅读
    2018-12-08 13:24:33

    编译器发现一个类中有虚函数,便会立即为此类生成虚函数表vtable。虚函数表的各表项为指向对应虚函数的指针。编译器还会为此类中隐含插入一个指针vptr(对vc编译器说,它插在类的第一位置上)指向虚函数表。调用此类的构造函数时,在类的构造函数中,编译器会隐含执行vptr与vtable的关联代码,将vptr指向相应的vtable,将类与此类的vtable联系起来。另外在调用类的构造函数时,指向基础类的指针此时已经变成指向具体的类的this指针,这样依靠此this指针即可得到正确的vtable,如此才能真正与函数体进行连接,这就是动态联编,实现多态的基本原理。

    虚函数是实现多态的基础。

    更多相关内容
  • 多态的理解以及作用

    千次阅读 2022-05-27 14:47:40
    一、多态是什么   多态在面向对象中的定义:指为不同数据类型的实体提供统一的接口。   比如有动物(Animal)之类别(Class),而且由动物继承出类别鸡(Chicken)和类别狗(Dog),并对同一源自类别动物(父类...

    一、多态是什么

      多态在面向对象中的定义:指为不同数据类型的实体提供统一的接口。
      比如有动物(Animal)之类别(Class),而且由动物继承出类别鸡(Chicken)和类别狗(Dog),并对同一源自类别动物(父类)之一消息有不同的响应,如类别动物有“叫()”之动作,而类别鸡会“啼叫()”,类别狗则会“吠叫()”,则称之为多态。

    二、多态的类型

      多态分为静态多态和动态多态。

    • 静态多态:在编译期间实现多态,相同的方法传递不同的参数,实现不同的效果。

      C++代码实现:

    // print()函数
    void print(const char* str,int width);
    void print(double i ,int width);
    void print(const char* str);
    // 使用print()函数时,编译器将根据所采取的用法使用有相应特征标的原型
    print("abc",12);
    print(2.2,55);
    print("def");
    
    • 动态多态:在运行期间实现多态,一个类的引用可以被赋值为不同的子类对象。

       实现动态多态的必要条件:

    • 编程语言要支持继承
    • 子类可以重写(override)父类中的方法
    • 父类引用可以指向子类对象

      C#代码实现:

    public class AnimalFactory{
    	public static Animal createAnimal(string type){
    		Animal animla=null;
    		switch(type){
    			case "cat":
    				animal=new Cat();
    				break;
    			case "bird":
    				animal=new Bird();
    				break;
    			case "dog":
    				animal=new Dog(); 
    				break;
    		}
    	}
    }
    

    三、多态解决什么问题

    1. 应用程序不必为每一个子类编写功能调用,只需要对父类进行处理即可。大大提高程序的可复用性。
    2. 子类的功能可以被父类的方法或引用变量所调用,就像Animal类,可以提高可扩充性和可维护性。
    展开全文
  • 1.多态的含义 什么是多态,就是一个事物有多种形态,比如说是老师是老师,他也是人,也是丈夫或者妻子,或者光棍儿,这就阐述了多种形态。

    1.多态的含义

    什么是多态,就是一个事物有多种形态,比如说是老师是老师,他也是人,也是丈夫或者妻子,或者光棍儿,这就阐述了多种形态。

    2.实现多态的三个前提条件

    2.1.继承/实现  2.2.方法重写  2.3.向上转型。

    3.多态的作用(即为好处)

    提高了了程序的扩展性(在举例种具体体现在一个对象(Person类)中调用usingCar方法,不需要对每一个子类Car对象进行创建对象,即就算子类多几种Car类型,只用在测试类中和再创建一个子类即可。)。

    4.多态的缺点

    虽然提高了程序的扩展性,但是不能使用子类的特有功能。就只能进行向下转型进行访问子类特有方法。

    5.多态的访问特点

    成员方法:编译看左边,执行看右边。(即为编译的时候先看父类中是否有这个成员方法,运行时运行的是子类中的方法)。

    成员变量:编译看左边,执行看左边。(即为编译的时候先看父类中是否有这个成员变量,运行时运行的是父类中的成员变量。

    下面是案例;

    1.先创建一个抽象父类AbstractCar(因为抽象类中有抽象方法,会必须要求子类重写抽象方法)

    public abstract class AbstractCar {
    	/**
    	 * 定义一个抽象方法
    	 */
    	public abstract void run(); //抽象方法,如果子类要继承,就要对抽象方法进行重写
    
    }

    2.创建2个子类(BMWCar和ChanganCar)去继承父类。

    public class BMWCar extends AbstractCar{
    	public String name = "宝马"; //这里创建一个成员变量是为了验证访问成员变量的特点
        // 无参构造方法
    	public BMWCar() {
    		// TODO Auto-generated constructor stub
    	}
    	
        //成员变量的getXxx/setXxx方法
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	/**
    	 * 要继承抽象类父类,就必须重写抽象类中父类的所有抽象方法
    	 */
    	public void run() {
    		System.out.println("宝马车跑起来了。");
    		
    	}
        
        //子类独有的方法(普通方法)
    	public void expensivePrice() {
    		System.out.println("宝马车贵的一批");
    		
    	}
    }
    

    2.1子类ChanganCar类

    public class ChanganCar extends AbstractCar{
    	/**
    	 * 要继承抽象类,就必须重写抽象类父类中的所有抽象方法
    	 */
    	@Override 
    	public void run() {
    		System.out.println("长安汽车跑起来了。");
    		
    	}
        // 子类特有方法(普通方法)
    	public void character() {
    		System.out.println("长安汽车性能一流,广告费结算一下。");		
    	}
    }

    3.定义一个Person类对AbstractCar子类进行操作

    下面代码中有个地方应该有很多看不明白,按照正常情况是按照我注释了的那种方式进行创建方法,但是这样会有一个问题,就是汽车品牌这么多,每一种品牌都需要单独的创建usingCar方法,这样会导致代码可读性差,而且代码冗余。所以利用多态的方式进行创建(将来如果有新的Car类只需要继承AbstractCar类,直接在测试类中创建对象就好了,就不需要再Person类中再次创建usingCar方法了。(不知道你们理解没?),反正子类要继承AbstractCar类,直接用多态进行接收就可以了,调用方法的时候还是会执行子类重写后的方法。

    public class Person {
    	/**
    	 * 定义一个方法 来输出car.run方法
    	 * 返回值类型:void
    	 * 参数 AbstractCar car
    	 */
    	
    	/*public void usingCar(BMWCar car) {
    		//AbstractCar car = new BMWCar();实例化对象
    		car.run();
    		//成员方法.编译看左边(有没有run方法),执行看右边。
    	}
    	public void usingCar(ChanganCar car) {
    		//AbstractCar car = new BMWCar();实例化对象
    		car.run();
    		//成员方法.编译看左边(有没有run方法),执行看右边。
    	}*/
    	
    	// 如果使用多态的方式创建,就会简化创建子类对象代码
    	public void usingCar(AbstractCar car) {
    		//AbstractCar car = new BMWCar();实例化对象
    		car.run();
    		//成员方法.编译看左边(有没有run方法),执行看右边。
    	}	
    }

    4.测试类

    public class AbstractTest {
    	public static void main(String[] args) {
    		
    		/**
    		 * 创建一个person对象来调用自己的usingCar方法
    		 * usingCar方法中的参数为AbstractCar(抽象汽车)类
    		 */
    		Person p = new Person();
    		AbstractCar bmwCar = new BMWCar();//使用多态的方式创建对象(实例化对象)
    		//上面多态的方式创建对象 是将new BMWCar()赋值给AbstractCar类用对象名bmwCar接收
    		//System.out.println(bmwCar.name);// 
            //访问成员方法 编译执行都看左边 (父类中没有name这个成员变量,即使有的话,会执行父类中的成员变量)
    		
    		p.usingCar(bmwCar);
    		
    		/**
    		 * 如果需要调用子类中的特有方法,应该怎么办?
    		 * 这个时候就需要强制转换(向下转型);
    		 * 强制转换(向下转型)语法:
    		 * 数据类型 变量 = (数据类型)值/变量;
    		 * 在向下转型前,必须进行类型判断,需要判断当前父类变量中装的是哪一个子类类型对象。
    		 * if(父类变量名 instanceof 子类类型1){
    		 *强制转换格式:
    		 *子类类型1 子类变量 = (子类类型1)父类变量;
    		 *现在就可以调用子类的特有方法
    		 * }else if(父类变量 instanceof 子类类型1){
    		 * .....}
    		 * 
    		 */
    		// 要想获取子类的成员方法和成员变量需要向下转型才能进行调用
            //方式一
    		if (bmwCar instanceof BMWCar) {
    			BMWCar bmw = (BMWCar)bmwCar;
    			bmw.stop();
    		}else if (bmwCar instanceof ChanganCar) {
    			ChanganCar changan = (ChanganCar)bmwCar;
    			changan.character();
    		}
    
            //方式二
            // getClass()方法返回字节码文件判断是否是VipZiuser1类型的对象
            if (bmwCar.getClass() == BMWCar.class) {
    			BMWCar bmw = (BMWCar)bmwCar;
    			bmw.stop();
    		}else if (bmwCar.getClass() == ChanganCar.class) {
    			ChanganCar changan = (ChanganCar)bmwCar;
    			changan.character();
    		}			
    	}
    }
    

    可以细心的进行分析;

    展开全文
  • 简述java多态

    2021-02-12 19:58:48
    java实现多态的前提:继承、覆写;2.覆写调用的前提:看new是哪个类的对象,而后看方法是否被子类覆写,若覆写则调用覆写的方法,若没覆写则调用父类的方法;二.多态性组成:1方法的多态性:方法重载:方法调用时...

    一.多态性:

    1。java实现多态的前提:继承、覆写;

    2.覆写调用的前提:看new是哪个类的对象,而后看方法是否被子类覆写,若覆写则调用覆写的方法,若没覆写则调用父类的方法;

    二.多态性组成:

    1方法的多态性:

    方法重载:方法调用时根据不同的参数个数和类型可以实现不同的功能

    方法覆写:不同的子类对于相同的方法可以有不同的实现;

    2对象的多态性:父类与子类之间的转换操作

    对象向上转型:父类 父类对象 = 子类实例,自动完成;

    对象向下转型:子类 子类对象 = (子类)父类实例,强制转换;

    四.总结:

    1向上转型(90%):为了实现参数类型的统一,但向上转型一定要和覆写配合使用;

    2向下转型(1%):为了调用子类的特使支持,可以用instanceof进行判断,但是有风险,不推荐使用;

    3不转型(9%):方便操作使用系统类或者一些功能类,如String或简单JAVA类;

    注意事项:

    1向上转型后父类对象不能调用子类中新建的方法,只能够调用子类中覆写的方法,向上转型之后牺牲了子类的个性化特征,若要调用新方法则要向下转型;

    2要向下转型之前一定要先进行向上转型,这样才可以建立父子关系;

    展开全文
  • java多态简述

    2021-03-18 10:17:31
    多态一、什么是多态多态根据其字面意思就是多种形态的意思,那么在Java中的多态指的是什么呢?指的是对象具有多种形态的意思,只是Java中分为引用多态和方法多态A.引用多态a.父类的引用指向本类的对象b.父类的引用...
  • 多态作用

    2013-05-01 22:26:54
    多态作用 1.隐藏实现细节,使得代码能够模块化;扩展代码模块,实现代码重用 2一个接口,多种接口的实现,很好的重用接口,   多态分两种多态 一种是静态多态,就是用模板具体化和函数重载解析来实现 一种...
  • 多态的定义和作用

    万次阅读 2018-03-25 00:08:40
    1多态(polymorphism)...2多态作用 1不必编写每一子类的功能调用,可以直接把不同子类当父类看,屏蔽子类间的差异,提高代码的通用率/复用率 2父类引用可以调用不同子类的功能,提高了代码的扩充性和可维护性...
  • 简述Java继承和多态

    2020-11-24 21:30:30
    JAVA继承和多态 一,继承 1,继承的概念 继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。 由继承而得到的类称为子类或者派生...
  • 多态是面向对象的三大特性之一,它使程序可以在运行时动态的绑定要执行的方法。在Java和C++中,有动态绑定静态绑定之分,今天我们就简单聊聊两种绑定在两种语言中的异同。 先对动态绑定和静态绑定两个概念做一个...
  • 简述什么是多态

    2021-01-21 18:24:49
    多态简述多态同一个行为具有多个不同表现形式或形态的能力。 是指一个类实例(对象)的相同方法在不同情形有不同表现形式。 多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着,虽然针对不同...
  • 多态概念及简述

    2022-01-25 16:20:18
    继承或实现是多态的前提。 一个对象拥有多种形态,简称“对象的多态性”。 方法才能覆盖重写,成员变量不可覆盖重写。 父类引用指向子类对象,格式: 父类名称 对象名 = new 子类名称(); 或者: 接口名称 ...
  • 封装和继承几乎都是为多态而准备的,在执行期间判断引用对象的实际类型,根据其实际的类型调用其相应的方法。  抽象: 表示对问题领域进行分析、设计中得出的抽象的概念,是对一系列看上去不同,但是本质上相同的...
  • 简述Java的多态

    2021-02-12 19:58:48
    对于Java的多态,最常见到的解释:多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将...
  • JAVA多态的概述及作用 战神三考:Why、What、How 1、为何用多态? 2、多态是什么? 3、多态怎么用? 1、为什么要用多态 1)提高了代码的维护性 (通过继承和实现来保证) 2)提高了代码的扩展性 (通过多态来保证) 3)...
  • 多态的概念及作用(理解)

    万次阅读 2018-04-13 09:41:35
    多态是面向对象的重要特性,简单说:“一个接口,多种实现”,就是同一种事物表现出的多种形态。编程就是一个将具体事务抽象化的过程,多态就是抽象化的一种体现,把一系列具体事务的...多态作用:1. 应用程序不...
  • c++多态:(调用相同函数名字) 多态三要素: 相同函数名字 依据上下文 实现却不同 实现多态的方式: 函数重载(编译期间) 虚函数(运行时)
  • java多态及其作用

    2018-01-16 16:01:30
    多态 多态:一个对象具备多种形态。(父类的引用类型变量指向了子类的对象)或者是接口 的引用类型变量指向了接口实现类的对象) 多态的前提:必须存在继承或者实现 关系。 动物 a = new 狗(); ...
  • Java的多态机制

    2022-01-23 22:11:46
    多态 1.概念 多态是面向对象的三大特征之一,指的是一种事物有多种形态,通过多态,我们可以提高程序的扩展力,降低程序的耦合度。 比如说有这样的一种场景:你养了小动物,小猫,小狗,小鸟,它们都是动物,每个小...
  • 多态一.概念:相同对象收到不同消息,或者,不同对象收到相同消息 二.静态多态(早绑定):在编译时,已确定使用哪个函数(eg:函数同名异参—函数重载) 三.动态多态(晚绑定):在运行时,才确定使用哪个函数...
  • c++ 多态原理详解

    2022-05-03 15:35:05
    编译时多态与运行时多态的区别: 1.时期不同:编译时多态发生在程序编译的过程中,运行时多态发生在程序运行过程中。 2.实现方式不同:编译时多态运用泛型编程来实现,运行时多态借助虚函数来实现。 3.虚表是何时...
  • 多态在开发中的作用: 从一个简单的作业题来体现: 不使用多态机制 public class Master{ //在不使用多态机制时,假如宠物为狗,呢么形参应该是Dog类型 public void feed(Dog d){ } //当宠物变成猫时,...
  • 什么是多态

    千次阅读 2020-10-24 00:37:07
    Java中的多态 一、 多态性的概述 面向对象的三大特征:封装性、继承性、多态性。 extends继承或者implements实现,无论是类与类之间的继承、类与接口之间的实现还是接口与接口间的继承,反正总会出现上下的层次关系...
  • 多态的实现原理

    千次阅读 2021-05-14 09:37:07
    多态的实现原理 多态的概念 多态的构成条件 虚函数 虚函数的重写(覆盖) 多态的原理 虚函数表指针及虚函数表 派生类的虚函数表 多态的概念 顾名思义,多态即多种形态。 定义:不同继承关系的类对象,调用同一函数,...
  • Java中多态详细介绍

    2022-04-25 15:57:02
    多态 (1)概述:同一个对象,在不同时刻表现出来的不同形态; 比如:猫,可以是猫,也可以是动物;这种表示形式就是多态多态的前提和体现:有继承/实现关系;有方法重写;有父类引用指向子类对象; (2)...
  • 多态的概念

    2021-07-12 17:18:19
    多态作用: a.将接口和实现分离 b.消除了类型之间的耦合关系 c.提高了程序的拓展性和可维护性 class Animal{ public void eat(){ }; } class dog extends Animal{ public void eat()
  • 在继承中,常常用到多态多态作用是什么啊,对于直接书写 之间的好处有那些啊?
  • 多态的基本概念

    2021-06-01 18:47:41
    文章目录1 多态的基本概念1.1 多态的概念 1 多态的基本概念 1.1 多态的概念 多态(Polymorphism )按字面的意思就是“多种状态”,是面向对象的程序设计语言最核心的特征。从一定角度来看,封装和继承几乎都是为多态而...
  • 简述C++多态与重载

    2019-11-27 11:39:10
    多态分为: 特设型多态: 特设强制多态:特设强制多态中的强制指的是隐式转换这样的语义操作,这使得期望某一类型的地方允许出现不同的类型而不会导致错误。例如: int a = 1; float b = a; // a 被隐式转换为...
  • 多态覆盖重写

    2013-10-18 21:24:29
    多态覆盖重写详细描述,完全代码讲解,真实例子

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,355
精华内容 6,542
关键字:

简述多态的作用