多态_多态性 - CSDN
多态 订阅
多态(Polymorphism)按字面的意思就是“多种状态”。在面向对象语言中,接口的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作(摘自“Delphi4 编程技术内幕”)。简单的说,就是一句话:允许将子类类型的指针赋值给父类类型的指针。多态性在Object Pascal和C++中都是通过虚函数实现的。 展开全文
多态(Polymorphism)按字面的意思就是“多种状态”。在面向对象语言中,接口的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作(摘自“Delphi4 编程技术内幕”)。简单的说,就是一句话:允许将子类类型的指针赋值给父类类型的指针。多态性在Object Pascal和C++中都是通过虚函数实现的。
信息
外文名
Polymorphism
类    型
概念
中文名
多态
解    释
多种状态
多态形式
多态指同一个实体同时具有多种形式。它是面向对象程序设计(OOP)的一个重要特征。如果一个语言只支持类而不支持多态,只能说明它是基于对象的,而不是面向对象的。C++中的多态性具体体现在运行和编译两个方面。运行时多态是动态多态,其具体引用的对象在运行时才能确定。编译时多态是静态多态,在编译时就可以确定对象使用的形式。多态:同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果。在运行时,可以通过指向基类的指针,来调用实现派生类中的方法。C++中,实现多态有以下方法:虚函数,抽象类,覆盖,模板(重载和多态无关)。OC中的多态:不同对象对同一消息的不同响应.子类可以重写父类的方法多态就是允许方法重名 参数或返回值可以是父类型传入或返回。多态也指生物学中腔肠动物的特殊的生活方式。水螅态与水母态的世代交替现象。
收起全文
精华内容
参与话题
  • java提高篇(三)-----理解java的三大特性之多态

    万次阅读 多人点赞 2016-11-22 09:31:50
    面向对象编程有三大特性:封装、继承、多态。  封装隐藏了类的内部实现机制,可以在不影响使用的情况下改变类的内部结构,同时也保护了数据。对外界而已它的内部细节是隐藏的,暴露给外界的只是它的访问方法。  ...

           面向对象编程有三大特性:封装、继承、多态。

           封装隐藏了类的内部实现机制,可以在不影响使用的情况下改变类的内部结构,同时也保护了数据。对外界而已它的内部细节是隐藏的,暴露给外界的只是它的访问方法。

           继承是为了重用父类代码。两个类若存在IS-A的关系就可以使用继承。,同时继承也为实现多态做了铺垫。那么什么是多态呢?多态的实现机制又是什么?请看我一一为你揭开:

           所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,即一个引用变量倒底会指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类,这样,不用修改源程序代码,就可以让引用变量绑定到各种不同的类实现上,从而导致该引用调用的具体方法随之改变,即不修改程序代码就可以改变程序运行时所绑定的具体代码,让程序可以选择多个运行状态,这就是多态性。

           比如你是一个酒神,对酒情有独钟。某日回家发现桌上有几个杯子里面都装了白酒,从外面看我们是不可能知道这是些什么酒,只有喝了之后才能够猜出来是何种酒。你一喝,这是剑南春、再喝这是五粮液、再喝这是酒鬼酒….在这里我们可以描述成如下:

           酒 a = 剑南春

           酒 b = 五粮液

           酒 c = 酒鬼酒

          

           这里所表现的的就是多态。剑南春、五粮液、酒鬼酒都是酒的子类,我们只是通过酒这一个父类就能够引用不同的子类,这就是多态——我们只有在运行的时候才会知道引用变量所指向的具体实例对象。

           诚然,要理解多态我们就必须要明白什么是“向上转型”。在继承中我们简单介绍了向上转型,这里就在啰嗦下:在上面的喝酒例子中,酒(Win)是父类,剑南春(JNC)、五粮液(WLY)、酒鬼酒(JGJ)是子类。我们定义如下代码:

           JNC a = new JNC();

           对于这个代码我们非常容易理解无非就是实例化了一个剑南春的对象嘛!但是这样呢?

           Wine a = new JNC();

           在这里我们这样理解,这里定义了一个Wine 类型的a,它指向JNC对象实例。由于JNC是继承与Wine,所以JNC可以自动向上转型为Wine,所以a是可以指向JNC实例对象的。这样做存在一个非常大的好处,在继承中我们知道子类是父类的扩展,它可以提供比父类更加强大的功能,如果我们定义了一个指向子类的父类引用类型,那么它除了能够引用父类的共性外,还可以使用子类强大的功能。

           但是向上转型存在一些缺憾,那就是它必定会导致一些方法和属性的丢失,而导致我们不能够获取它们。所以父类类型的引用可以调用父类中定义的所有属性和方法,对于只存在与子类中的方法和属性它就望尘莫及了---1。

    public class Wine {
        public void fun1(){
            System.out.println("Wine 的Fun.....");
            fun2();
        }
        
        public void fun2(){
            System.out.println("Wine 的Fun2...");
        }
    }
    
    public class JNC extends Wine{
        /**
         * @desc 子类重写父类方法
         *        父类中不存在该方法,向上转型后,父类是不能引用该方法的
         * @param a
         * @return void
         */
        public void fun1(String a){
            System.out.println("JNC 的 Fun1...");
            fun2();
        }
        
        /**
         * 子类重写父类方法
         * 指向子类的父类引用调用fun2时,必定是调用该方法
         */
        public void fun2(){
            System.out.println("JNC 的Fun2...");
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            Wine a = new JNC();
            a.fun1();
        }
    }
    -------------------------------------------------
    Output:
    Wine 的Fun.....
    JNC 的Fun2...

          从程序的运行结果中我们发现,a.fun1()首先是运行父类Wine中的fun1().然后再运行子类JNC中的fun2()。

          分析:在这个程序中子类JNC重载了父类Wine的方法fun1(),重写fun2(),而且重载后的fun1(String a)与 fun1()不是同一个方法,由于父类中没有该方法,向上转型后会丢失该方法,所以执行JNC的Wine类型引用是不能引用fun1(String a)方法。而子类JNC重写了fun2() ,那么指向JNC的Wine引用会调用JNC中fun2()方法。

          所以对于多态我们可以总结如下:

          指向子类的父类引用由于向上转型了,它只能访问父类中拥有的方法和属性,而对于子类中存在而父类中不存在的方法,该引用是不能使用的,尽管是重载该方法。若子类重写了父类中的某些方法,在调用该些方法的时候,必定是使用子类中定义的这些方法(动态连接、动态调用)。

          对于面向对象而已,多态分为编译时多态和运行时多态。其中编辑时多态是静态的,主要是指方法的重载,它是根据参数列表的不同来区分不同的函数,通过编辑之后会变成两个不同的函数,在运行时谈不上多态。而运行时多态是动态的,它是通过动态绑定来实现的,也就是我们所说的多态性。

           多态的实现

          2.1实现条件

          在刚刚开始就提到了继承在为多态的实现做了准备。子类Child继承父类Father,我们可以编写一个指向子类的父类类型引用,该引用既可以处理父类Father对象,也可以处理子类Child对象,当相同的消息发送给子类或者父类对象时,该对象就会根据自己所属的引用而执行不同的行为,这就是多态。即多态性就是相同的消息使得不同的类做出不同的响应。

          Java实现多态有三个必要条件:继承、重写、向上转型。

             继承:在多态中必须存在有继承关系的子类和父类。

             重写:子类对父类中某些方法进行重新定义,在调用这些方法时就会调用子类的方法。

             向上转型:在多态中需要将子类的引用赋给父类对象,只有这样该引用才能够具备技能调用父类的方法和子类的方法。

          只有满足了上述三个条件,我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象,从而达到执行不同的行为。

          对于Java而言,它多态的实现机制遵循一个原则:当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法。


          2.2实现形式

          在Java中有两种形式可以实现多态。继承和接口。

          2.2.1、基于继承实现的多态

          基于继承的实现机制主要表现在父类和继承该父类的一个或多个子类对某些方法的重写,多个子类对同一方法的重写可以表现出不同的行为。

    public class Wine {
        private String name;
        
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Wine(){
        }
        
        public String drink(){
            return "喝的是 " + getName();
        }
        
        /**
         * 重写toString()
         */
        public String toString(){
            return null;
        }
    }
    
    public class JNC extends Wine{
        public JNC(){
            setName("JNC");
        }
        
        /**
         * 重写父类方法,实现多态
         */
        public String drink(){
            return "喝的是 " + getName();
        }
        
        /**
         * 重写toString()
         */
        public String toString(){
            return "Wine : " + getName();
        }
    }
    
    public class JGJ extends Wine{
        public JGJ(){
            setName("JGJ");
        }
        
        /**
         * 重写父类方法,实现多态
         */
        public String drink(){
            return "喝的是 " + getName();
        }
        
        /**
         * 重写toString()
         */
        public String toString(){
            return "Wine : " + getName();
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            //定义父类数组
            Wine[] wines = new Wine[2];
            //定义两个子类
            JNC jnc = new JNC();
            JGJ jgj = new JGJ();
            
            //父类引用子类对象
            wines[0] = jnc;
            wines[1] = jgj;
            
            for(int i = 0 ; i < 2 ; i++){
                System.out.println(wines[i].toString() + "--" + wines[i].drink());
            }
            System.out.println("-------------------------------");
    
        }
    }
    OUTPUT:
    Wine : JNC--喝的是 JNC
    Wine : JGJ--喝的是 JGJ
    -------------------------------

          在上面的代码中JNC、JGJ继承Wine,并且重写了drink()、toString()方法,程序运行结果是调用子类中方法,输出JNC、JGJ的名称,这就是多态的表现。不同的对象可以执行相同的行为,但是他们都需要通过自己的实现方式来执行,这就要得益于向上转型了。

          我们都知道所有的类都继承自超类Object,toString()方法也是Object中方法,当我们这样写时:

    Object o = new JGJ();
    System.out.println(o.toString());

          输出的结果是Wine : JGJ。

          Object、Wine、JGJ三者继承链关系是:JGJ—>Wine—>Object。所以我们可以这样说:当子类重写父类的方法被调用时,只有对象继承链中的最末端的方法才会被调用。但是注意如果这样写:

    Object o = new Wine();
    System.out.println(o.toString());

          输出的结果应该是Null,因为JGJ并不存在于该对象继承链中。

          所以基于继承实现的多态可以总结如下:对于引用子类的父类类型,在处理该引用时,它适用于继承该父类的所有子类,子类对象的不同,对方法的实现也就不同,执行相同动作产生的行为也就不同

          如果父类是抽象类,那么子类必须要实现父类中所有的抽象方法,这样该父类所有的子类一定存在统一的对外接口,但其内部的具体实现可以各异。这样我们就可以使用顶层类提供的统一接口来处理该层次的方法。

          2.2.2、基于接口实现的多态

          继承是通过重写父类的同一方法的几个不同子类来体现的,那么就可就是通过实现接口并覆盖接口中同一方法的几不同的类体现的。

          在接口的多态中,指向接口的引用必须是指定这实现了该接口的一个类的实例程序,在运行时,根据对象引用的实际类型来执行对应的方法。

          继承都是单继承,只能为一组相关的类提供一致的服务接口。但是接口可以是多继承多实现,它能够利用一组相关或者不相关的接口进行组合与扩充,能够对外提供一致的服务接口。所以它相对于继承来说有更好的灵活性。

          三、经典实例。

          通过上面的讲述,可以说是对多态有了一定的了解。现在趁热打铁,看一个实例。该实例是有关多态的经典例子,摘自:http://blog.csdn.net/thinkGhoster/archive/2008/04/19/2307001.aspx

    public class A {
        public String show(D obj) {
            return ("A and D");
        }
    
        public String show(A obj) {
            return ("A and A");
        } 
    
    }
    
    public class B extends A{
        public String show(B obj){
            return ("B and B");
        }
        
        public String show(A obj){
            return ("B and A");
        } 
    }
    
    public class C extends B{
    
    }
    
    public class D extends B{
    
    }
    
    public class Test {
        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--" + a1.show(c));
            System.out.println("3--" + a1.show(d));
            System.out.println("4--" + a2.show(b));
            System.out.println("5--" + a2.show(c));
            System.out.println("6--" + a2.show(d));
            System.out.println("7--" + b.show(b));
            System.out.println("8--" + b.show(c));
            System.out.println("9--" + b.show(d));      
        }
    }

          运行结果:

    1--A and A
    2--A and A
    3--A and D
    4--B and A
    5--B and A
    6--A and D
    7--B and B
    8--B and B
    9--A and D

          在这里看结果1、2、3还好理解,从4开始就开始糊涂了,对于4来说为什么输出不是“B and B”呢?

          首先我们先看一句话:当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法。这句话对多态进行了一个概括。其实在继承链中对象方法的调用存在一个优先级:this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

          分析:

          从上面的程序中我们可以看出A、B、C、D存在如下关系。


          首先我们分析5,a2.show(c),a2是A类型的引用变量,所以this就代表了A,a2.show(c),它在A类中找发现没有找到,于是到A的超类中找(super),由于A没有超类(Object除外),所以跳到第三级,也就是this.show((super)O),C的超类有B、A,所以(super)O为B、A,this同样是A,这里在A中找到了show(A obj),同时由于a2是B类的一个引用且B类重写了show(A obj),因此最终会调用子类B类的show(A obj)方法,结果也就是B and A。

          按照同样的方法我也可以确认其他的答案。

          方法已经找到了但是我们这里还是存在一点疑问,我们还是来看这句话:当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法。这我们用一个例子来说明这句话所代表的含义:a2.show(b);

          这里a2是引用变量,为A类型,它引用的是B对象,因此按照上面那句话的意思是说有B来决定调用谁的方法,所以a2.show(b)应该要调用B中的show(B obj),产生的结果应该是“B and B”,但是为什么会与前面的运行结果产生差异呢?这里我们忽略了后面那句话“但是这儿被调用的方法必须是在超类中定义过的”,那么show(B obj)在A类中存在吗?根本就不存在!所以这句话在这里不适用?那么难道是这句话错误了?非也!其实这句话还隐含这这句话:它仍然要按照继承链中调用方法的优先级来确认。所以它才会在A类中找到show(A obj),同时由于B重写了该方法所以才会调用B类中的方法,否则就会调用A类中的方法。

          所以多态机制遵循的原则概括为:当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法,但是它仍然要根据继承链中方法调用的优先级来确认方法,该优先级为:this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

          参考资料:http://blog.csdn.net/thinkGhoster/archive/2008/04/19/2307001.aspx

          百度文库:http://wenku.baidu.com/view/73f66f92daef5ef7ba0d3c03.html

          在这里面向对象的三大特性已经介绍完成,下一步继续是java基础部分—巩固基础,提高技术,不惧困难,攀登高峰!!!!!!

          更多:

              ava提高篇-----理解java的三大特性之封装

           java提高篇-----理解java的三大特性之继承



    展开全文
  • java基础——多态

    千次阅读 2020-06-29 15:28:42
    抽象类的多态 场景描述 一位刚毕业的老师,目前只能通过骑车上班,多年后终于坐骑升级了,有了自己的小汽车,于是骑着小汽车上班。 骑自行车上班 1.自行车类 public class Bick{//自行车类 public void start(){ ...

    抽象类的多态

    场景描述

    一位刚毕业的老师,目前只能通过骑车上班,多年后终于坐骑升级了,有了自己的小汽车,于是骑着小汽车上班。

    骑自行车上班

    1.自行车类

    public class Bike{//自行车类
    	public void start(){
    		System.out.println("自行车-启动:握好把手,踩下脚踏板...");
    	}
    	public void stop(){
    		System.out.println("自行车-停止:捏刹车...");
    	}
    }
    

    2.教师类

    public class Teacher {
    	public void open(Bike bike) {
    		bike.start();
    	}
    	
    	public void close(Bike bike){
    		Bike bike.stop();
    	}
    }
    
    1. 测试类
    public class Test01 {
    	public static void main(String[] args) {
    		Teacher t = new Teacher();
    		Bike bike = new bike();
    		t.open(bike);
    		System.out.println("欣赏沿途的风景...");
    		t.close(bike);
    	}
    }
    

    开小车上班

    如果此时我们还是这样先去写一个小汽车类,然后在教师类里重载open和close方法,那么这样是不是会觉得代码冗余呢,有些朋友会说并没有,那当我们面对更多人,以及更多的上班方式时,那你是不是要分别为他们准备一套,那样未必太麻烦了,而且还会破坏OCP原则;这时,我们就可以用多态的方式完成这样,只需要提取一个交通工具类,然后当需求增加的时候我们直接扩充这个交通工具类就可以了。
    OCP原则 - 开闭原则:需求改动,竟可能少影响原有代码
    * O - open :对创建类,是欢迎的
    * C - close:对原有代码进行修改,是拒绝的
    * p - principle:原则

    1. Vehicle类(交通工具)
    public abstract class Vehicle {
    	
    	public abstract void start();
    
    	public abstract void stop();
    }
    
    1. Bike 类(自行车类)
    public class Bike extends Vehicle{
    	
    	@Override
    	public void start(){
    		System.out.println("自行车-启动:握好把手,踩下脚踏板...");
    	}
    	
    	@Override
    	public void stop(){
    		System.out.println("自行车-停止:捏刹车...");
    	}
    
    }
    
    1. Car类(小汽车类)
    public class Car extends Vehicle{
    
    	@Override
    	public void start(){
    		System.out.println("小汽车-启动:系好安全带,一键启动,打转向灯,松手差,挂挡,踩油门");
    	}
    	
    	@Override
    	public void stop(){
    		System.out.println("小汽车-停止:踩刹车,挂P档,拉手刹,关大灯,熄火,解开安全带");
    	}
    }
    
    1. Teacher类(需求者类)
    public class Teacher {
    	
    	public void open(Vehicle v) {
    		v.start();
    	}
    	
    	public void close(Vehicle v){
    		v.stop();
    	}
    }
    
    1. Test类(测试类)
    public class Test01 {
    	
    	public static void main(String[] args) {
    		Teacher t1 = new Teacher();
    		//类的多态:子类对象指向父类引用
    		//类的多态:父类引用存储了子类对象的内存地址
    		Vehicle v = new Bike();
    		
    		t1.open(v);
    		System.out.println("欣赏沿途的风景...");
    		t1.close(v);
    		System.out.println("...................");
    		Teacher t2 = new Teacher();
    		Vehicle vehicle = new Car();
    		t2.open(vehicle);
    		System.out.println("欣赏沿途的风景...");
    		t2.close(vehicle);
    	}
    }
    

    在这里插入图片描述
    在我们升级后,如果需求增加时,比如有一个电动车的需求,那么我们的步骤就应该是,创建一个电动车的类去继承交通工具类,然后重写交通工具类的抽象方法。创建电动车对象指向父类引用,再交给给需求者使用便可。在这里同样是调用t.open(v);和t.close(v);这是结果就不一样的。这就是多态的结果,不同人都要上班,就一个上班的动作,而产生上班方式的结果不一样。

    提示

    以上只是我自己的看法,如有相同纯属意外。如有错误,也请谅解,勿喷!如有收获或疑问,欢迎点赞评论!

    展开全文
  • 什么是多态?为什么要使用多态

    万次阅读 多人点赞 2018-05-22 23:02:22
    这就是多态。这句话很好理解:Person person = new Student("张三");但是这个多态有什么作用呢?而我们又为什么要是有多态呢?首先讲下封装和继承:封装是把过程和数据包围起来,对数据的访问只能通过已...

    用最简单的一句话就是:父类型的引用指向子类型的对象。用一句比较通俗的话:同一操作作用于不同的对象,可以产生不同的效果。这就是多态。

    这句话很好理解:Person person = new Student("张三");但是这个多态有什么作用呢?而我们又为什么要是有多态呢?

    首先讲下封装和继承:封装是把过程和数据包围起来,对数据的访问只能通过已定义的界面,他把实现的细节影藏起来了,比如你在java中去实现一个类,这个类中提供了一些功能方法,你只需要知道你需要传递什么样的参数,会达到什么样的效果,实现细节在类中定义好了。从而使得代码模块化;而继承可以扩展已存在的代码模块,而目的就是为了代码重用。

    那么多态除了代码的复用,还可以解耦。然而为什么要解耦?耦合度讲的是模块模块之间,代码代码之间的关联度,通过对系统的分析把他分解成一个一个子模块,子模块提供稳定的接口,达到降低系统耦合度的的目的,模块模块之间尽量使用模块接口访问,而不是随意引用其他模块的成员变量。

    多态有什么好处?

    有两个好处:

    1. 应用程序不必为每一个派生类编写功能调用,只需要对抽象基类进行处理即可。大大提高程序的可复用性。//继承 
    2. 派生类的功能可以被基类的方法或引用变量所调用,这叫向后兼容,可以提高可扩充性和可维护性。 //多态的真正作用,

     

    多态在什么地方用?

    可以用在方法的参数中和方法的返回类型中。

    在方法中的参数,请看下面的例子:

    复制代码
       public abstract class Driver
        {
            public void run();//让子类来运行
        }
    
    
    class SBenz : Driver
        {
            public void run()
            {
                Console.WriteLine("Benz在以200迈的速度在run");
            }
        }
    
    
    
    
     class JD : Driver
        {
            public void run()
            {
                Console.WriteLine("JD is running...");
            }
        }
    
    
     class Person
        {
            private Driver driver;
            public Person()
            {
    
            }
            public Person(Driver driver)
            {
                this.driver = driver;
            }
            public void drive()
            {
                driver.run();
            }
            public void setDriver(Driver driver)
            {//运用参数多态,以后不管买什么车都可以
                this.driver = driver;
            }
       }
    
    
    
    
    static void Main(string[] args)
            {
                Person p = new Person();
                JD jd = new JD();//刚开始没钱就买辆JD吧
                p.setDriver(jd);
                p.drive();
                SBenz benz = new SBenz();//有钱换车了
                p.setDriver(benz);
                p.drive();
            }
    复制代码

     

    在方法的返回类型中,请看下面的例子:

    上面的例子中,不管是JD还是Benz都是我们自己直接new出来的.我们可以设计一个工厂类,专门生成汽车

    /**
    *   我们将多态使用在方法的返回类型中
    *   Driver可以是抽象类,也可以是接口,JD和Benz分别继承该类或实现该借口

    */

    复制代码
     public class CarFactory
        {
            public Driver factory(String carName)
            {
                if (carName.Equals("JD"))
                {
                    return new JD();
                }
    
                else if (carName.Equals("Benz"))
                {
                    return new SBenz();
                }
    
                else
                {
                    Console.WriteLine("对比起,不伺候");
                    return null;
                }
            }
        }
    复制代码

    这实际上就是设计模式中的简单工厂模式!

    类型的参数.,传入参数的时候,可以传入任何一个类的对象,只要是对应的类的对象名称就可以了
    这就是多态的应用!




    展开全文
  • C++ 之 多态(非常非常重要,重点在后面)

    万次阅读 多人点赞 2018-08-16 14:29:07
    什么是多态? 顾名思义就是同一个事物,在不同场景下的多种形态。 下面会具体的详细的介绍。

    编译环境:WIN10 VS2017
    这篇博客有点长,但都是满满的干货,一定要看到最后,那才是重点。
    什么是多态
    顾名思义就是同一个事物在不同场景下的多种形态。
    这里写图片描述
    下面会具体的详细的介绍。

    静态多态

    我们以前说过的函数重载就是一个简单的静态多态

    int Add(int left, int right)
    {
        return left + right;
    }
    double Add(double left, int right)
    {
        return left + right;
    }
    
    int main()
    {
        Add(10, 20);
        //Add(10.0, 20.0);  //这是一个问题代码
        Add(10.0,20);  //正常代码
        return 0;
    }

    这里写图片描述
    可以看出来,静态多态是编译器在编译期间完成的,编译器会根据实参类型来选择调用合适的函数,如果有合适的函数可以调用就调,没有的话就会发出警告或者报错。。。比较简单,不做多介绍。
    这里写图片描述

    动态多态

    什么是动态多态呢?
    动态多态: 显然这和静态多态是一组反义词,它是在程序运行时根据基类的引用(指针)指向的对象来确定自己具体该调用哪一个类的虚函数。
    我在西安临潼上学,我就以这边的公交车举个栗子啊:

    class TakeBus
    {
    public:
        void TakeBusToSubway()
        {
            cout << "go to Subway--->please take bus of 318" << endl;
        }
        void TakeBusToStation()
        {
            cout << "go to Station--->pelase Take Bus of 306 or 915" << endl;
        }
    };
    //知道了去哪要做什么车可不行,我们还得知道有没有这个车
    class Bus
    {
    public:
        virtual void TakeBusToSomewhere(TakeBus& tb) = 0;  //???为什么要等于0
    };
    
    class Subway:public Bus
    {
    public:
        virtual void TakeBusToSomewhere(TakeBus& tb)
        {
            tb.TakeBusToSubway();
        }
    };
    class Station :public Bus
    {
    public:
        virtual void TakeBusToSomewhere(TakeBus& tb)
        {
            tb.TakeBusToStation();
        }
    };
    
    int main()
    {
        TakeBus tb;
        Bus* b = NULL;
        //假设有十辆公交车,如果是奇数就是去地铁口的,反之就是去火车站的
        for (int i = 1; i <= 10; ++i)
        {
            if ((rand() % i) & 1)
                b = new Subway;
            else
                b = new Station;
        }
        b->TakeBusToSomewhere(tb);
        delete b;
        return 0;
    }

    这就是一个简单的动态多态的例子,它是在程序运行时根据条件去选择调用哪一个函数。
    而且,从上面的例子我们还发现了我在每一个函数前都加了virtual这个虚拟关键字,想想为什么?如果不加会不会构成多态呢?
    干想不如上机实践:

    class Base
    {
    public:
        virtual void Funtest1(int i)
        {
            cout << "Base::Funtest1()" << endl;
        }
        void Funtest2(int i)
        {
            cout << "Base::Funtest2()" << endl;
        }
    };
    class Drived :public Base
    {
        virtual void Funtest1(int i)
        {
            cout << "Drived::Fubtest1()" << endl;
        }
        virtual void Funtest2(int i)
        {
            cout << "Drived::Fubtest2()" << endl;
        }
        void Funtest2(int i)
        {
            cout << "Drived::Fubtest2()" << endl;
        }
    };
    void TestVirtual(Base& b)
    {
        b.Funtest1(1);
        b.Funtest2(2);
    }
    int main()
    {
        Base b;
        Drived d;
        TestVirtual(b);
        TestVirtual(d);
        return 0;
    }

    这里写图片描述
    在调用FuncTest2的时候我们看出来他并没有给我们调用派生类的函数,因此我们可以对动态多态的实现做个总结。

    动态多态的条件:
    ●基类中必须包含虚函数,并且派生类中一定要对基类中的虚函数进行重写
    ●通过基类对象的指针或者引用调用虚函数。

    重写
    (a)基类中将被重写的函数必须为虚函数(上面的检测用例已经证实过了)
    (b)基类和派生类中虚函数的原型必须保持一致(返回值类型,函数名称以及参数列表),协变和析构函数(基类和派生类的析构函数是不一样的)除外
    (c)访问限定符可以不同
    那么问题又来了,什么是协变?
    协变:基类(或者派生类)的虚函数返回基类(派生类)的指针(引用)
    总结一道面试题:那些函数不能定义为虚函数?
    经检验下面的几个函数都不能定义为虚函数:
    1)友元函数,它不是类的成员函数
    2)全局函数
    3)静态成员函数,它没有this指针
    3)构造函数,拷贝构造函数,以及赋值运算符重载(可以但是一般不建议作为虚函数)

    抽象类:
    在前面公交车的例子上我提了一个问题:

    class Bus
    {
    public:
        virtual void TakeBusToSomewhere(TakeBus& tb) = 0;  //???为什么要等于0
    };

    在成员函数(必须为虚函数)的形参列表后面写上=0,则成员函数为纯虚函数。包含纯虚函数的类叫做抽象类(也叫接口类),抽象类不能实例化出对象。纯虚函数在派生类中重新定义以后,派生类才能实例化出对象。纯虚函数是一定要被继承的,否则它存在没有任何意义。

    这里写图片描述

    多态调用原理

    class Base
    {
    public:
        virtual void Funtest1(int i)
        {
            cout << "Base::Funtest1()" << endl;
        }
        virtual void Funtest2(int i)
        {
            cout << "Base::Funtest2()" << endl;
        }
        int _data;
    };
    
    int main()
    {
        cout << sizeof(Base) << endl;
        Base b;
        b._data = 10;
        return 0;
    }

    这里写图片描述
    8?不知道大家有没有问题,反正我是有疑惑了。以前在对象模型(https://blog.csdn.net/qq_39412582/article/details/80808754)时我提到过怎么来求一个类的大小。按照那个方法,这里应该是4才对啊,为什么会是8呢?

    通过观察。我们发现这个例子里面和以前不一样,类成员函数变成了虚函数,这是不是引起类大小变化的原因呢?
    我们假设就是这样,然后看看内存里是怎么存储的呢?
    这里写图片描述
    可以看到它在内存里多了四个字节,那这四个字节的内容到底是什么呢?

    这里写图片描述

    是不是有点看不懂,我们假设它是一个地址去看地址里存的东西的时候发现它存的是两个地址。
    我假设它是虚函数的地址,我们来验证一下:

    typedef void (__stdcall *PVFT)();  //函数指针
    int main()
    {
        cout << sizeof(Base) << endl;
        Base b;
        b._data = 10;
        PVFT* pVFT = (PVFT*)(*((int*)&b));
        while (*pVFT)
        {
            (*pVFT)();
            pVFT+=1;
        }
        return 0;
    }

    这里写图片描述
    结果好像和我们的猜想一样,是一件开心的事。然后我给一张图总结一下:
    这里写图片描述
    在反汇编中我们还可以看到,如果含有虚函数的类中没有定义构造函数,编译器会自动合成一个构造函数
    这里写图片描述

    这里写图片描述

    对于派生类的东西我给个链接仔细看,人家总结的超级赞,我偷个懒就不写了,老铁们包容下啊。

    派生类虚表:
    1.先将基类的虚表中的内容拷贝一份
    2.如果派生类对基类中的虚函数进行重写,使用派生类的虚函数替换相同偏移量位置的基类虚函数
    3.如果派生类中新增加自己的虚函数,按照其在派生类中的声明次序,放在上述虚函数之后
    https://coolshell.cn/articles/12176.html

    多态缺陷

    ●降低了程序运行效率(多态需要去找虚表的地址)
    ●空间浪费

    展开全文
  • 多态

    2020-06-01 21:35:31
    多态 同一个对象体现出来的多种不同的形态(身份),将一种行为表现出不同的效果 要想实现多态的效果,需要先有继承关系 体现: 通过父类类型的引用指向子类的对象 Person p = new Teacher(); 该引用只能调用...
  • 多态~

    2020-09-24 19:53:42
    多态的使用:即虚拟方法调用 有了对象的多态性后,我们在编译期,只能调用父类中声明的方法,但在运行期,我们实际执行的是子类重写父类的方法。 多态性的使用前提:类的继承关系、子类重写了父类的方法 对象的多态...
  • 关于多态

    2020-10-23 20:29:31
    关于多态 1.多态是什么 多态是同一个行为具有多个不同表现形式或形态的能力。 多态(Polymorphism)按字面的意思就是“多种状态”。在面向对象语言中,接口的多种不同的实现方式即为多态。引用Charlie Calverts对...
  • 什么是多态?为什么用多态?有什么好处?

    万次阅读 多人点赞 2018-07-13 16:48:56
    多态可以分为变量的多态,方法的多态,类的多态.我这里强调的是类的多态,这是我们在以后的工作中经常回用到的首先,有这样一个系统:有个学生工作从达内毕业了,作的还不错.买了辆捷达汽车.这个系统应该如何设计呢?按照OO...
  • 什么是多态?为什么使用多态

    万次阅读 2017-09-18 20:22:57
    看Java核心技术这本书时,多态的内容讲解的很少,只是举个例子告诉我们怎样使用多态,而没有明确说明为什么使用多态的问题。 谈到面向对象的编程语言时不可避免的就会介绍继承,子类可以继承父类除private外的成员...
  • java多态的理解(运行时多态

    万次阅读 多人点赞 2019-07-09 18:25:45
    说道多态,一定离不开其它两大特性:封装和继承。而多态是在它们的基础之上表现而来的,息息相关。在记忆中,每一次学习面向对象的时候,都与这三大特性有扯不开的关系,其是面向对象的重点,当然也算是难点。但是,...
  • 多态是怎么实现的?

    千次阅读 2018-08-10 13:32:05
    VB语言支持类,但它不支持多态,所以VB是一个基于对象而非面向对象的语言。 多态性:同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果。要理解多态,首先要了解程序的执行过程: 1. 源程序通过...
  • Java多态

    千次阅读 多人点赞 2019-10-28 11:36:23
    我们学习多态一定要明确下面这几点注意事项 ※什么是多态 多态就是对同一个对象,在不同时刻表现出来的不同形态 ※多态的前提条件有哪些 要有继承/实现关系 要有方法重写 要有父类引用指向子类对象 ※ 多态的成员...
  • 多态,大概每个人都知道。但是,又有几个人真的理解什么是多态多态有哪些细节呢?如果你看到这篇文章的名字,脑海中对多态没有一个清晰的概念,不妨点进来看看,也许会有收获。
1 2 3 4 5 ... 20
收藏数 287,312
精华内容 114,924
关键字:

多态