精华内容
下载资源
问答
  • 对象的多态性指的是什么
    千次阅读
    2020-05-08 16:52:21

    多态性是面向对象编程的又一个重要特征,它是指在父类中定义的属性和方法被子类 继承之后,可以具有不同的数据类型或表现出不同的行为
    Java 实现多态有 3 个必要条件:继承、重写和向上转型。
    1、继承:在多态中必须存在有继承关系的子类和父类。
    2、重写:子类对父类中某些方法进行重新定义,在调用这些方法时就会调用子类的方法。
    3、向上转型:在多态中需要将子类的引用赋给父类对象,只有这样该引用才既能可以 调用父类的方法,又能调用子类的方法。父类引用不能调用子类特有的方法。、

    多态性,是面向对象中最重要的概念,在java中有两 种体现:

    1. 方法的重载(overload)和重写(overwrite)。
    2. 对象的多态性 :父类的引用指向子类对象实体
      可以直接应用在抽象类和接口上

    对象的多态 Person p = new Staff();
    Object o = new Person();//Object类型的变量o,指向Person类 型的对象
    o = new Staff (); //Object类型的变量o,指向Staff类型的 对象 虚拟方法调用(多态情况下)
    Person a= new Student();
    e.getInfo(); //调用Staff类的getInfo()方法
    编译时a为Person类型,而方法的调用是在运行时确定的,所以 调用的是Student类的getInfo()方法。

    更多相关内容
  • C#中多态性的实现

    2021-01-20 02:01:05
    多态是一个行为具有多个不同表现形式的能力,在C#中通过多态性的检测时机可以分为静态多态性和动态多态性 静态多态性:函数重载和运算符重载 动态多态性:抽象方法、重写方法、隐藏方法 二:函数重载(overlode) ...
  • 所谓多态性就是一段程序能够处理多种类型对象的能力,在PHP中,多态值的就是方法的重写。方法重写是一个子类中可以重新修改父类中的某些方法,使其具有自己的特征。重写要求子类的方法和父类的方法名称相同,...
  • 对象多态性

    千次阅读 2018-05-19 21:48:41
    方法的覆盖(重写):同一个方法会根据子类的不同,实现不同的功能 对象多态性的是发生在继承关系类之中,子类和父类之间的转换问题1.向上转型(自动完成):父类 父类对象 = 子类实例;2.向下转型(强制转换)...

    多态性严格来讲有两种描述形式:  

      方法的多态性:

    1.方法的重载:同一个方法名称会根据传入参数的类型及个数不同会执行不同的方法体

    2.方法的覆盖(重写):同一个方法会根据子类的不同,实现不同的功能

      对象的多态性:指的是发生在继承关系类之中,子类和父类之间的转换问题

    1.向上转型(自动完成):父类 父类对象 = 子类实例;

    2.向下转型(强制转换):子类 子类对象 =(子类) 父类实例;     eg:long型数据与int型数据的相互转换

    范例:向上转型

    class A{
    	public void print() {
    			System.out.println("A.public static void main()");
    	}
    }
    class B extends A{
    	  public void print() {
    		  	System.out.println("B.public static void main()");
    	  }
    }
    public class TestDemo {
           public static void main(String[] args) {
        	   A  a=new B();        //向上转型
        	   a.print();
    	
    } 
           }  

    范例:向下转型

    class A{
    	public void print() {
    			System.out.println("A.public static void main()");
    	}
    }
    class B extends A{
    	  public void print() {
    		  	System.out.println("B.public static void main()");
    	  }
    }
    public class TestDemo {
           public static void main(String[] args) {
        	   A  a=new B();
        	   B  b=(B) a;  //向下转型
    	      b.print();
    } 
           }  

    向上转型:由于所有的子类对象实例都可以自动的向上转型,所以在于参数的统一上。参数统一之后,还可以调用子类覆盖后的方法体,即:同一个方法针对于不同的子类可以有不同的实现。

    向下转型:指的是父类要调用子类自己特殊的方法。所有的父类发生了向上转型后只能看见父类自己定义的全部方法信息,但看不见子类特殊的方法,于是此时就要使用向下转型了。将父类对象转换为子类对象。这样就可以使用子类的特殊功能了。

    对于对象的转型,给出以下的总结:

    1.   80%的情况下都只会使用向上转型,因为可以得到参数类型的统一,方便于我们的程序设计;

         子类定义的方法大部分情况下请以父类的方法名称为标准进行复写。不要过多的扩充方法。

    2.   5%的情况下,会使用向下转型,目的是调用子类的特殊方法;

    3.   15%的情况下是不转型的,例如:String.

    个性化的操作在一个标准的开发之中应该尽量少出现,因为对象的转型操作里面毕竟有强制转换的问题,容易带来安全隐患。

    向下转型建立在向上转型的基础上!


    展开全文
  • 到底什么是多态性”?

    千次阅读 2020-07-22 10:31:36
    * 多态面向的是对象的是对象多态性 * -------------------------------------------------- * 代码中的多态性,其实就是一句话,父类引用指向子类对象,就是父类可以引用不同子类的对象,产

    1.多态的基本概念

    /**
     * @author : sunkepeng E-mail:sunkepengouc@163.com
     * @date : 2020/7/22 8:57
     *面向对象有三大特征:封装、继承、多态
     * 封装、继承是面向于类或者接口;
     * 多态面向的是对象,指的是对象的多态性
     * --------------------------------------------------
     * 代码中的多态性,其实就是一句话,父类引用指向子类对象,就是父类可以引用不同子类的对象,产生不同种 
     * 形态
     * 格式:
     * 父类名称 对象名 = new 之类名称();
     * 或者:
     * 接口名称 对象名 = new 实现类名称();
     */
    public class Multi {
        public static void main(String[] args) {
            // 使用多态方法
            // 左侧父类的调用,指向右侧子类的对象
            // 一只猫被当做动物看待是没有问题的
            Animal obj = new Cat();
    
            obj.method();    // 子类方法,new的是谁就指向谁
            obj.methodFu();  // 父类特有方法,如果子类没有,就会向上找父类
        }
    }
    /**
     * @author : sunkepeng E-mail:sunkepengouc@163.com
     * @date : 2020/7/22 8:59
     */
    public class Animal {
        public void method(){
            System.out.println("父类方法");
        }
        public void methodFu(){
            System.out.println("父类特有方法");
        }
    }
    /**
     * @author : sunkepeng E-mail:sunkepengouc@163.com
     * @date : 2020/7/22 9:00
     */
    public class Cat extends Animal {
    
        @Override
        public void method(){
            System.out.println("子类方法");
        }
    }

    2.多态成员变量的使用特点

    /**
     * @author : sunkepeng E-mail:sunkepengouc@163.com
     * @date : 2020/7/22 9:14
     *访问成员变量的两种方式:
     *
     * 1.直接通过对象名称访问成员变量:看等号左边是谁,优先用谁,没有则向上找,不会向下找。
     * 2.间接通过成员方法访问成员变量: 看该方法属于谁,优先用谁,没有则向上找,不会向下找。
     */
    public class Multi {
        public static void main(String[] args) {
            // 使用多态的写法,父类引用指向子类对象
            Fu fu = new Zi();
            System.out.println(fu.num);
    //        System.out.println(fu.age); // 错误写法,向下查找
    
            // 子类没有覆盖重写父类方法,就是父:10
            // 子类如果覆盖重写父类方法,就是子:20
            fu.showNum();
        }
    }
    /**
     * @author : sunkepeng E-mail:sunkepengouc@163.com
     * @date : 2020/7/22 9:14
     */
    public class Fu {
        int num = 10;
    
        public void showNum(){
            System.out.println(num);
        }
    }
    
    /**
     * @author : sunkepeng E-mail:sunkepengouc@163.com
     * @date : 2020/7/22 9:14
     */
    public class Zi extends Fu {
        int num = 20;
        int age = 16;
    
        @Override
        public void showNum() {
            System.out.println(num);
        }
    }
    

    3.多态成员方法的访问规则

    /**
     * @author : sunkepeng E-mail:sunkepengouc@163.com
     * @date : 2020/7/22 9:14
     *访问成员变量的两种方式:
     *
     * 1.直接通过对象名称访问成员变量:看等号左边是谁,优先用谁,没有则向上找,不会向下找。
     * 2.间接通过成员方法访问成员变量: 看该方法属于谁,优先用谁,没有则向上找,不会向下找。
     *
     * 在多态的代码当中成员方法的访问规则是:
     *  *  看new的是谁,就优先使用谁,没有则向上找。
     *
     * 口诀:编译看左边,运行看右边。
     */
    public class Multi {
        public static void main(String[] args) {
            // 使用多态的写法,父类引用指向子类对象
            Fu obj = new Zi();
            System.out.println(obj.num);
    //        System.out.println(fu.age); // 错误写法,向下查找
    
            // 子类没有覆盖重写父类方法,就是父:10
            // 子类如果覆盖重写父类方法,就是子:20
            obj.showNum();
    
            // 编译看左面,没问题;运行的时候method()是运行的子类中的方法
            obj.method();   // 子类是new的,并且有,先用子类
            // 编译看左面,没问题;运行的时候method()是运行的子类中的方法,子类中没有向上找到父类
            obj.methodFu(); // 子类没有向上找
    
            // 编译看左边,左边是Fu obj(),没有methodZi(),所以编译报如下错误
    //        obj.methodZi();  // 错误写法
        }
    }
    /**
     * @author : sunkepeng E-mail:sunkepengouc@163.com
     * @date : 2020/7/22 9:14
     */
    public class Fu {
        int num = 10;
    
        public void showNum(){
            System.out.println(num);
        }
    
        public void method(){
            System.out.println("父类方法");
        }
    
        public void methodFu(){
            System.out.println("父类特有方法");
        }
    }
    /**
     * @author : sunkepeng E-mail:sunkepengouc@163.com
     * @date : 2020/7/22 9:14
     */
    public class Zi extends Fu {
        int num = 20;
        int age = 16;
    
        @Override
        public void showNum() {
            System.out.println(num);
        }
    
        @Override
        public void method() {
            System.out.println("子类方法");
        }
    
        public void methodZi(){
            System.out.println("子类特有方法");
        }
    }

    4.使用口诀

    成员变量:编译看左边,运行还是看左边

    成员方法:编译看左边,运行看右边

    5.多态的用处

    就上图示例,等号左面的都是Employee对象,不关心等号右面是讲师、助教、保安等,使得代码更加灵活

    展开全文
  •  广义上说,多态性一段程序能够处理多种类型对象的能力。在C++中,这种多态性可以通过重载多态(函数和运算符重载),强制重载(类型强制转换),类型参数化多态(模板) ,包含多态(继承与虚函数)四种方式
  • 什么是多态性多态性是继数据抽象和继承后,面向对象语言的第三个特征。从字面上理解,多态的意思是“多种形态”,简单来说,多态是具有表现多种形态的能力的特征,在OO中是“语言具有根据对象的类型以不同方式...
  • 面向对象多态性

    千次阅读 2017-12-25 21:16:12
    2. 面向对象多态性 3. 抽象类与接口   A.Object类  ·Object类是所有Java类的根基类(“祖先类”)  ·如果在类的声明中未使用extends关键字指明其基类,则  默认基类为Object类    a.to

    学习目标:

    1. Object类的toString()与equals(Object  obj)方法

    2. 面向对象的多态性

    3. 抽象类与接口

     

    A.Object类

         ·Object类是所有Java类的根基类(“祖先类”)

         ·如果在类的声明中未使用extends关键字指明其基类,则

           默认基类为Object类

          

         a.toString方法

            1.Object类中定义有public  String toString()方法,

              其返回值是String类型,描述当前对象的有关信息

           ***如果直接打印某对象的引用,则默认会调用这个对象的

              toString()方法,默认打印的内容中包含这个引用所指

              向的内存地址

             


             


                 

     

           2.可以根据需要在用户自定义类中重写toString()方法

           


           

                                 

         b.equals( )方法

            1.Object类中定义有publicboolean equals(Object obj)

              方法,提供定义对象是否“相等”的逻辑

           2.Object的equals方法定义为:x.equals(y),当x和y指向同

             一个地址时返回true,否则返回false

           3.String类中已经重写了equals(Object obj)方法,重写后的

             方法比较的是两个字符串的内容是否一样

             (注意:==比较对象的引用)

           4.可以根据需要在用户自定义类型中重写equals方法

             

                

    B.多态性

         ·封装是为了保护属性的一种操作,继承是为了扩展类的功能

         ·是由封装性继承性引出的面向对象程序设计语言的另一种特征

         a.多态的体现

           1.从方法的角度来看

             ·方法的重载和重写

              (1)重载(overloading):根据传入的参数不同,完成的

                                      功能也不同

              (2)重写(override):子类根据需求重写父类中的方法

           2.从对象的角度来看

             ·对象的多态性主要分为两种:

              (1)向上转型:子类对象--->父类对象(程序会自动完成)

                    格式:父类  父类对象=子类实例

                   或者  父类  父类对象=new 子类

                ***向上转型后,因为操作的是父类对象,所以无法找

                   到在子类中定义的新方法;但如果子类重写了父类的

                   某个方法,则调用的是重写后的方法  

            

            

            

            

      

         

         

             

              (2)向下转型:父类对象--->子类对象 (必须明确的指明转型的子类类型)

                   格式:子类  子类对象=(子类)父类实例

                   注意:向下转型前先要向上转型

       


        

         

             

         b.instanceof关键字

           1.在java中可以使用instanceof关键字判断一个对象是否属于一个类的实例

           2.格式:对象  instanceof  类--->返回boolean类型

         


            


            

        


              

        c.final关键字

           1.在JAVA中声明类、属性和方法时,可以使用关键字final来修饰

           2.注意:

             (1)final修饰变量(成员变量或局部变量),则成为

                  常量,只能赋值一次

                  final 类型  variableName;

                  修饰成员变量时,定义时同时给出初始值,而修饰

                  局部变量时不做要求

                                                  

             (2)final修饰方法,则该方法不能被子类重写

                  final 返回值类型  methodName(paramList)

                  {

                      …

                  }

                  

                  

             (3)final修饰类,则类不能被继承

                  final classfinalClassName{

                      …

                  }

                              

                   

    C.抽象类与接口

        ·用abstract修饰的类即为抽象类

             abstract class 抽象类名{

             }

     

        ·抽象类不能被实例化,必须被继承,抽象方法必须被重写,生成它

          的子类

        ·abstract修饰的方法就是抽象方法,抽象方法没有方法体

        ·抽象类不一定要包含抽象方法,若类中包含了抽象方法,则该类必须

          被定义为抽象类

        ·如果一个子类没有实现抽象父类中所有的抽象方法,则子类也成为一

          个抽象类

        ·构造方法、静态方法、私有方法、final方法不能被声明为抽象的方法

                          


                        


                        

                         

                                 

          ***如果子类也是一个抽象类,则可以不用重写父类的抽象方法,但是

             当子类的子类为非抽象类时,子类的子类要重写子类的抽象方法,

             并且要将子类未重写的父类的抽象方法也写上

             


             

         a.接口

            ·接口(interface)是抽象方法和常量值的定义的集合

            ·接口是一种“标准”、“契约”。

            ·从本质上讲,接口是一种特殊的抽象类,这种抽象类中只能包含

              常量和方法的定义,而没有变量和方法的实现

            1.接口的声明语法

              (1)包括接口声明和接口体

              (2)完整的接口声明:

                [public] interface接口名称[extends listOfSuperInterface] { … }

              (3)接口体包括常量定义和方法定义

                   ·常量定义: typeNAME=value;  该常量被实现该接口的多

                     个类共享; 具有public,final, static的属性.

                   ·方法体定义:具有 public和abstract属性

            2.接口的实现类

              (1)与抽象类一样,接口要使用也必须通过子类,子类通过

                   implements关键字实现接口

              (2)一个类可以实现多个接口,implements子句中用逗号分开

              (3)非抽象子类必须实现接口中定义的所有方法

              (4)实现格式:

                   ·class子类 implements接口A,接口B…{

                     }

            3.接口的使用规则

              (1)接口中所有的方法都是public abstract 

              (2)在接口中声明方法时,不能使用static,final,synchronized,

                   private,protected等修饰符

              (3)一个接口可以继承自另一个接口

              (4)java中不允许类的多继承,但允许接口的多继承

              (5)接口中可以有数据成员,这些成员默认都是public static final

            4.接口的用途

              (1)通过接口实现不相关类的相同行为,而无需考虑这些类之间的关系

              (2)通过接口指明多个类需要实现的方法

              (3)通过接口了解对象的交互界面,而无需了解对象所对应的类

            5.eg1:

                 

                 

                 

                 

                 

                  

              eg2:

                 

                 

                 

                  

                  

              eg3:

                 

                 

                  

                  

                   

                   

              eg4:

                  

                  

                   

                   

                    

                     

           

     

            

            

      

             

               

    展开全文
  • 多态性(polymorphism)是面向...在C ++程序设计中,多态性具有不同功能的函数可以用同一个函数名,这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般是这样表述多态性的:向不同的对象发送同一个消息
  • 什么是多态 同一个行为具有个不同表现形式或...这种多态通过动态绑定(dynamic binding)技术来实现,是在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法。也就是说,只有程序运行起来,你才
  • Java多态性什么是Java的多态性

    千次阅读 2021-02-19 18:28:58
    了解Java多态性什么是Java的多态性(向上转型)多态性的前提为什么使用多态性多态性的使用向下转型instanceof运算符 什么是Java的多态性(向上转型) Java的多态性是事物的多种形态,是运行时行为(向上转型,子类...
  • C++基础:什么是C++的多态性

    千次阅读 2020-12-28 18:50:10
    多态性可以简单地概括为“一个接口,多种方法”,程序在运行时才决定调用的函数,它是面向对象编程领域的核心概念。多态(polymorphisn),字面意思多种形状。 C++多态性是通过虚函数来实现的,虚函数允许子类重新定义...
  • 1.9 多态性什么是多态?

    千次阅读 2020-09-29 11:07:08
    多态性是面向对象编程的又一个重要特征,它是在父类中定义的属性和方法被子类继承之后,可以具有不同的数据类型或表现出不同的行为,这使得同一个属性或方法在父类及其各个子类中具有不同的含义。 对面向对象来说...
  • 多态的概念:同一个方法,在不同的情境下会有不同的表现 多态的核心体现主要有以下两点: ...二、对象多态性 前提:方法覆写 (1)对象的向上转型 父类 父类对象=new 子类(); 核心作用:操作参数统一...
  • Python是一种纯粹的面向对象语言。面向对象编程中的四大特征分别是:抽象、封装、继承和多态。多态根据上下文,对象可以采用多种形式。程序将确定该对象每次执行所需的含义或用法,从而减少了重复代码。 我国有句...
  • 基础篇——面向对象多态性详解

    千次阅读 2018-04-24 16:24:08
    每一个思路要用到哪些语句、方法和对象。 4.代码实现。用具体的语言代码将思路实现出来。学习新技术的四点: 1.该技术是什么? 2.该技术有什么特点?(使用需注意的方面) 3.该技术怎么使用?(写Demo) 4.该技术...
  • 面向对象编程:多态性(C++)

    千次阅读 多人点赞 2020-04-25 16:31:54
    面向对象编程:多态性(C++) 文章目录面向对象编程:多态性(C++)一、简介二、类继承层次中对象之间的关系 一、简介 1、介绍:同样的消息给各种不同的对象时,会产生多种形式的结果,这就是多态性。 注: (1)、...
  • 多态性相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果。不同的对象,收到同一消息将可以产生不同的结果,这种现象称为多态性多态性允许每个对象以适合自身的方式去响应共同的消息。多态性...
  • 理解误区——方法的重载是多态性的一种体现? 方法的重载是多态性的一种体现吗? 其实这是一个误区,让我很长的一段时间都理解错了,直到又一次系统复习Java的时候才理解,方法的重载并不是是多态性...什么才是多态性
  • 类的多态性

    千次阅读 2018-07-23 19:48:03
    我们在习惯上把类的多态性称为事物存在的多种体现形态 1.何为多态?  例如 :超人 extends 人类  超人 麦克 = new 超人();  人 麦克 = new 超人();  可以看出,我们在new出的这个实体,它既具备超人的特征,...
  • Java多态性:Java什么是多态?

    千次阅读 2019-07-07 21:58:08
    多态性是面向对象编程的又一个重要特征,它是在父类中定义的属性和方法被子类继承之后,可以具有不同的数据类型或表现出不同的行为,这使得同一个属性或方法在父类及其各个子类中具有不同的含义。 对面向对象来说...
  • 1、什么多态性 【定义】 (1)在面向对象方法中,不同对象收到相同的消息时,产生不同的行为(即方法) (2)在C++程序设计中,多态性用一个名字定义不同的函数,函数执行不同但类似的操作,可以实现用同一...
  • C++之多态性

    万次阅读 多人点赞 2019-06-05 00:25:31
    在面向对象方法中,所谓多态性就是不同对象收到相同消息,产生不同的行为。在C++程序设计中,多态性用一个名字定义不同的函数,这些函数执行不同但又类似的操作,这样就可以用同一个函数名调用不同内容的函数。...
  • * 第10章 多态性和虚函数 面向对象的系统常常要求一组具有相同基本语义的方法能在同一接口下为不同的对象服务这就是所谓的多态性polymorphism 所谓多态性发出同样的消息被不同类型的对象接收时导致完全不同的...
  • 多态性和函数应用C++语言程序设计 多态性和函数...多态性的概念 多态性是面向对象程序设计的重要特征之一 多态性发出同样的消息被不同类型的对象接收时有可能导致完全不同的行为 多态的实现 函数重载 运算符重载
  • 面向对象(四)多态以及多态性

    千次阅读 2018-04-16 15:11:00
    在面向对象方法中一般是这样表述多态性:向不同的对象发送同一条消息(!!!obj.func():是调用了obj的方法func,又称为向obj发送了一条消息func),不同的对象在接收时会产生不同的行为(即方法)。也就是说,每个...
  • [Java教程]多态性的表现形式

    千次阅读 2021-03-17 10:52:51
    什么是多态面向对象多态性就是将父类对象应用到子类对象的特征。简单地讲,多态的就是在应用程序中出现的“重名”现象。多态性允许以统一的风格编写程序,以处理种类繁多的已存在的类和相关类。这样既降低了维护...
  • 多态性有哪些,怎么实现

    千次阅读 2018-07-23 21:20:06
    C++的多态性:在基类的函数前加上virtual关键字,在派生类中重写该函数,相同的对象收到不同的消息或者不同的对象收到相同的消息时产生的不同的实现动作。如果对象类型是派生类,就调用派生类的函数;如果对象类型...
  • 一、封装性 二、继承性 三、多态性

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 94,646
精华内容 37,858
热门标签
关键字:

对象的多态性指的是什么