精华内容
下载资源
问答
  • java多态性的概念
    2018-06-08 22:34:29
       

          运行时多态性是面向对象程序设计代码重用的一个最强大机制,Java多态性的概念也可以被说成“一个接口,多个方法”。Java实现运行时多态性的基础是动态方法调度,它是一种在运行时而不是在编译期调用重载方法的机制。

          方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现,重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数,我们说该方法被重写(Overriding)。子类的对象使用这个方法时,将调用子类中的定义,对它而言,父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法,它们或有不同的参数个数或有不同的参数类型,则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现,重载Overloading是一个类中Java多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数,我们说该方法被重写 (Overriding)。子类的对象使用这个方法时,将调用子类中的定义,对它而言,父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法,它们或有不同的参数个数或有不同的参数类型,则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

        当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法。 (但是如果强制把超类转换成子类的话,就可以调用子类中新添加而超类没有的方法了。)

    更多相关内容
  • Java多态性,什么是Java的多态性

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

    什么是Java的多态性(向上转型)

    Java的多态性是事物的多种形态,是运行时行为(向上转型,子类可以赋值给父类),父亲的行为像儿子。

    多态性的前提

    1. 继承性(必须有父类和子类,才会有把子类赋值给父类的情况)
    2. 子类重写了父类的方法(如果子类不重写父类的方法,调用的就还是父类的方法)

    为什么使用多态性?

    多态性可以减少重载函数的使用,可以调用子类重写后的方法

    多态性的使用

    当调用子父类同名方法同参数的方法时,调用只能调用父类中申明过的方法,但是实际上执行的是子类重写父类的方法(编译看左边,执行看右边)。也就是虚拟方法的调用。
    主函数中,父类调用子类重写的行为

    class Person {
        private String name;
        private String age;
    
        public String getName() {
            System.out.println("我是父类");
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAge() {
            return age;
        }
    
        public void setAge(String age) {
            this.age = age;
        }
    }
    

    在子类Man中

    class  Man extends Person{
        private String name;
        private String age;
    
    
        @Override
        public String getName() {
            return name;
        }
    
        @Override
        public void setName(String name) {
            System.out.println("我是男人的姓名");
            this.name = name;
        }
    
        @Override
        public String getAge() {
            System.out.println("我是男人的年龄");
            return age;
        }
    
        @Override
        public void setAge(String age) {
            this.age = age;
        }
    
        public void earnMoney(){
            System.out.println("男人可以赚钱");
        }
    }
    
      Person person=new Man();
            person.getName();//输出结果:我是男人的姓名
    

    例:多态性减少重载函数的使用
    想要得到父类的年龄,也想得到子类的年龄,要写两个重载函数

      private void testAge(Man man){
            System.out.println(man.getAge());
        }
        private void testAge(Person person){
            System.out.println(person.getAge());
        }
    

    然后再主函数调用

            test.testAge(new Man());
            test.testAge(new Person());
    

    使用Java多态性后,只需要保留一个方法

    private void testAge(Person person){
            System.out.println(person.getAge());
        }
    

    调用时:

            test.testAge(new Man());
            test.testAge(new Person());
    

    向下转型

    在使用多态性的时候,父类new了一个子类时,其实子类的所有方法都会加载,但是如果父类没有申明子类的方法,也就是说子类并没有重写父类的方法,而是自定义了一个方法,那么我们如何使用多态性使得父类的对象能够调用子类的特有的方法呢?意味着需要将父类对象如果直接使用赋值符号,在基本数据类型中是有一个自动类型提升的说法,但是类类型的不能使用自动类型提升,只能使用强制类型转换。

            Person person=new Man();
            Man man=(Man) person;
            man.earnMoney();
    

    强制类型转换的时候会出现异常,比如如下情况:地址值相同但是类型不相同

            Person person=new Man();
            Man man=(Man) person;
            Woman woman=(Woman) person;
    

    为了避免这种情况,我们使用instanceof运算符

    instanceof运算符

    1. a instanceof A 判断a 是不是 instanceof 的实例
    Person person=new Man();
            if (person instanceof Man){
                Man man= (Man) person;
                man.earnMoney();
            }
            if (person instanceof Woman){
                Woman woman= (Woman) person;
                woman.goshopping();
            }
    
    展开全文
  • 主要介绍了Java多态性定义与用法,较为详细的分析了多态的概念、功能以及java定义与实现面向对象多态性的相关操作技巧,需要的朋友可以参考下
  • 主要介绍了java 多态性详解及简单实例的相关资料,需要的朋友可以参考下
  • 主要介绍了Java中多态性的实现方式,什么是多态?通过简单的一道题目帮大家理解java多态性,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 运行时多态性是面向对象程序设计代码重用的一个最强大机制,动态性的概念也可以被说成“一个接口,多个方法”。Java实现运行时多态性的基础是动态方法调度,它是一种在运行时而不是在编译期调用重载方法的机制,下面...
  • 主要介绍了Java面向对象程序设计多态性,结合实例形式分析了java多态性概念、原理、定义与使用方法及相关注意事项,需要的朋友可以参考下
  • java中 多态的概念

    千次阅读 2022-03-15 00:33:53
    public class Demo_test { /* * 多态规则 * 1 多态是方法的多态,属性没有多态 * 2父类和子类有联系,注意类型转换ClassCastExeception * 3 存在条件:继承关系,方法需要重写,父类引用指向子类对象 ...

    public class Demo_test {
    /*
    * 多态规则
    * 1 多态是方法的多态,属性没有多态
    * 2父类和子类有联系,注意类型转换ClassCastExeception
    * 3 存在条件:继承关系,方法需要重写,父类引用指向子类对象
    * */

    /*
    * static静态方法不能被重写,属于类方法,  static修饰的方法和类一起加载, 非static和对象一起加载
    * final 常量修饰
    * pribave私有方法,无法重写
    * */
    
        public static void main(String[] args) {
            tear std_tear = new std();//父类引用指向子类,正常只能调用父类方法,调用子类需要向下转型
            std std = new std();//子类自己对象
            tear tear = new tear();//父类自己对象
    
            tear.phoen();//父类调用自己phone的方法
    
            std.book();//子类调用父类的phone方法
    
            std.phoen();//子类调用自己的phone(重写父类phone)
    
            std_tear.write();//父类引用调用父类独有方法
    
            std_tear.phoen();//父类类调用子类phone(已经重写父类phone)
    
            ((std) std).book(); //父类引用调用子类,强制向下转型调用子类方法
        }
    }
    class std extends tear{
        int a = 0;
    
        public void book(){//调用父类方法
            super.phoen();
        }
    
        @Override//重新父类方法
        public void phoen() {
            System.out.println("son phone");
        }
    }
    class tear{
        int b =1;
        public void phoen(){
            System.out.println("father phone");
        }
        public void write(){
            System.out.println("father write");
        }
    }
    
    展开全文
  • java中的多态性

    千次阅读 2020-07-07 14:11:23
    多态性,是面向对象中最重要的概念,在Java中的体现: 对象的多态性:父类的引用指向子类的对象 可以直接应用在抽象类和接口上 Java引用变量有两个类型: 编译时类型和 运行时类型。编译时类型由声明该变量时使用...

    java中的多态性

    1.基本概念
    多态性,是面向对象中最重要的概念,在Java中的体现:

    对象的多态性:父类的引用指向子类的对象
    可以直接应用在抽象类和接口上

    Java引用变量有两个类型: 编译时类型和 运行时类型。编译时类型由声明该变量时使用的类型决定,运行时类型由实际赋给该变量的对象决定。简称:编译时,看左边;运行时,看右边。

    若编译时类型和运行时类型不一致 , 就出现了对象的多态性

    多态情况下 , “ 看左边 ” : 看的是父类的引用(父类中不具备子类特有的方法)
    “ 看右边 ” : 看的是子类的对象(实际运行的是子类重写父类的方法)

    2.对象的多态
    对象的多态 —在Java中,子类的对象可以替代父类的对象使用
    一个变量只能有一种确定的数据类型
    一个引用类型变量可能指向(引用)多种不同类型的对象

    Person p = new Student();
    Object o = new Person();//Object类型的变量o,指向Person类型的对象
    o = new Student(); //Object类型的变量o,指向Student类型的对象
    

    子类可看做是特殊的父类 , 所以父类类型的引用可以指向子类的对象:向型上转型(upcasting)。

    3.属性没有多态
    一个引用类型变量如果声明为父类的类型,但实际引用的是子类
    对象,那么该变量就不能再访问子类中添加的属性和方法

    Student m = new Student();
    m.school = “pku”;  // 合法,Student 类有school 成员变量
    Person e = new Student();
    e.school = “pku”; // 非法,Person 类没有school 成员变量
    

    属性是在编译时确定的,编译时e 为Person 类型,没有school成员变量,因而编译错误。

    4.多态应用举例
    方法声明的形参类型为父类类型,可以使用子类的对象作为实参调用该方法

    public class Test {
    	public void method(Person e) {
    		// ……
    		e.getInfo();
    	}
    	public static void main(Stirng args[]) {
    		Test t = new Test();
    		Student m = new Student();
    		t.method(m); // 子类的对象m传送给父类类型的参数e
    	}
    }
    

    5.虚拟方法调用
    正常的方法调用

    Person e = new Person();
    e.getInfo();
    Student e = new Student();
    e.getInfo();
    

    虚拟方法调用(多态情况下)
    子 类中定义了与父类同名同参数的方法,在多态情况下,将此时父类的方法称为虚拟方法,父类根据赋给它的不同子类对象,动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。

    Person e = new Student();
    e.getInfo(); // 调用Student 类的getInfo()
    

    编译时类型和运行时类型
    编译时e 为Person 类型,而方法的调用是在运行时确定的,所以调用的是Student类的getInfo() 方法。——动态绑定

    虚拟方法调用举例:
    在这里插入图片描述
    6.方法的重载与重写
    从编译和运行的角度看:
    重载,是指允许存在多个同名方法,而这些方法的参数不同。编译器根据方法不同的参数表,对同名方法的名称做修饰。对于编译器而言,这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的,即子类可以重载父类的同名不同参数的方法。

    所以:对于重载而言,在方法调用之前,编译器就已经确定了所要调用的方法,这称为“早绑定”或“静态绑定”;

    而对于多态,只有等到方法调用的那一刻,解释运行器才会确定所要调用的具体方法,这称为“晚绑定”或“动态绑定”。

    引用一句Bruce Eckel的话:“不要犯傻,如果它不是晚绑定,它就不是多态。”

    7.多态总结
    多态作用:
    提高了代码的通用性,常称作接口重用

    前提
    需要存在继承或者实现关系
    有方法的重写

    成员方法:
    编译时:要查看引用变量所声明的类中是否有所调用的方法。
    运行时:调用实际new的对象所属的类中的重写方法。

    成员变量:
    不具备多态性,只看引用变量所声明的类。

    展开全文
  • Java程序设计:chapter06 多态性.ppt
  • Java多态性:Java什么是多态?

    千次阅读 2019-07-07 21:58:08
    多态性是面向对象编程的又一个重要特征,它是指在父类中定义的属性和方法被子类继承之后,可以具有不同的数据类型或表现出不同的行为,这使得同一个属性或方法在父类及其各个子类中具有不同的含义。 对面向对象来说...
  • C#类的多态性详解

    2021-01-20 06:39:52
    第一种:编译时的多态性,直接这样说不知道说啥?程序执行过程主要分为三步:编译,链接,运行。在编译时体现的多态性是通过方法的重载来实现的。方法的重载我们听过,就是一个类对象调用若干同名,但参数类型、个数...
  • java多态性

    千次阅读 2017-12-06 22:29:42
    一、基础概念  1.多态的定义: 允许不同类的对象对同一消息做出响应,同一消息可以根据发送对象的不同而采用多种不同的行为方式。    2.实现多态的必要条件:继承、重写、向上转型。(向上转型:在多态中需要将...
  • JavaJava静态多态性与动态多态性

    千次阅读 2014-10-11 17:18:08
    静态多态性指的是程序在编译时,系统就能决定调用哪个函数,如重载。 动态多态性指在运行中才能动态确定操作指针所指的对象,主要通过虚函数和重写来实现。 java 的多态机制遵循一个原则:当父类对象引用变量引用...
  • 继承是为了重用父类代码,同时为实现多态性作准备。那么什么是多态呢?方法的重写、重载与动态连接构成多态性Java之所以引入多态的概念,原因之一是它在类的继承问题上和C++不同,后者允许多继承,这确实给其带来...
  • Java中的多态性

    千次阅读 2016-03-26 09:56:07
    通过讲Java中的上塑造型引出了多态的重要
  • 深入浅出java多态性,为什么要有多态

    千次阅读 2020-04-08 11:39:22
    相比于封装和继承,多态似乎理解起来更加抽象,这篇文章将彻底揭露java多态性,文章内容较多,请耐心观看 1.通过代码体现多态性 我们先准备好三个类,男人类male,女人类female,以及他们共同的父类person类 public ...
  • 封装 面向对象的特征一:封装与隐藏 1.为什么要引入封装? 我们程序设计追求“高内聚,低耦合”。 高内聚 :类的内部数据操作细节自己完成,不允许外部干涉; 低耦合 :仅对外暴露少量的方法用于使用。 隐藏对象...
  • Java多态性面向对象编程有三个特征,即封装、继承和多态。封装隐藏了类的内部实现机制,从而可以在不影响使用者的前提下改变类的内部结构,同时保护了数据。继承是为了重用父类代码,同时为实现多态性作准备。那么...
  • 主要介绍了进一步理解Java中的多态概念,是Java入门学习中的基础知识,需要的朋友可以参考下
  • Java多态性探悉()

    2008-11-26 16:36:26
    Java多态性探悉 .......推荐。、。
  • 深入理解Java多态性

    千次阅读 2013-11-21 13:07:40
    看过一些关于Java多态性的文章,参考了很多人的理解,加入了一些自己的看法,整理出来供大家参考,不一定完全正确,欢迎大家批评指正。 (一)相关类 class A ...{  public String show(D obj)...{  return ("A...
  • Java多态性详解 (父类引用子类对象)

    千次阅读 2021-02-25 20:34:44
    继承是为了重用父类代码,同时为实现多态性作准备。那么什么是多态呢?方法的重写、重载与动态连接构成多态性Java之所以引入多态的概念,原因之一是它在类的继承问题上和C++不同,后者允许多继承,这确实给其带来...
  • 多态性 虚拟方法调用

    2022-01-30 11:17:17
    多态性,是面向对象中最重要的概念,在Java中的体现: 对象的多态性:父类的引用指向子类的对象 可以直接应用在抽象类和接口上 二、使用步骤 1.Java引用变量有两个类型: 编译时类型和 运行时类型。 编译时...
  • Java多态性理解(重要)

    千次阅读 2018-06-23 04:10:24
    来源:...这是我们最后一个概念,也是最重要的知识点。多态的定义:指允许不同类的对象对同一消息做出响应。即同一消息可以根据发...
  • java 简述类的封装性、继承性、多态性

    千次阅读 热门讨论 2016-09-22 15:53:12
    一:什么是封装性、继承性、多态性  封装性:通俗说就是一个盒子,多个对象、功能、组件等装在一个盒子里,内部具体是什么不知道,用到它时,使用特定方法或功能去调用它。即声明一个变量(其属性值是private)不...
  • Java基础概念

    2015-10-20 12:36:58
    多态性包括参数化多态性和包含多态性多态性语言具有灵活、抽象、行为共享、代码共享的优势, 2、 Java的基本数据类型都有什么?String是基本数据类型吗? 基本数据类型包括int、short、byte、double、boolean、...
  • Java多态性理解,好处及精典实例

    万次阅读 多人点赞 2016-10-26 20:12:09
    例如,在实现了圆锥、半圆锥以及半球体的多态基础上,很容易增添球体类的多态性。 3. 接口性(interface-ability)。 多态是超类通过方法签名,向子类提供了一个共同接口,由子类来完善或者覆盖它而实现的。如图8.3...
  • 说什么 继承和多态赋值 使用继承和多态的概念创建一个 3D 形状对象,将其属性应用于其他形状,如球体、圆锥体、圆柱体等。 请阅读 asg5.doc 以获取原始作业说明。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 66,310
精华内容 26,524
关键字:

java多态性的概念