精华内容
下载资源
问答
  • java面向对象多态特性

    2021-03-09 09:03:47
    java作为面向对象的语言,同样可以形容一个事物的多种形态,java多态的代码表现在一个子类对象(实现类对象)既可以给这个子类(实现类对象)引用变量赋值,又可以给这个子类(实现类对象)的父类(接口) 变量赋值。...

    一、多态的概念

    多态是继封装,继承之后,面向对象的三大特性。

    现实事物经常会表现出多种形态,如学生,学生是人的一种,则一个具体的张三同学既是学生也是人,即出现两种形态。

    java作为面向对象的语言,同样可以形容一个事物的多种形态,java中多态的代码表现在一个子类对象(实现类对象)既可以给这个子类(实现类对象)引用变量赋值,又可以给这个子类(实现类对象)的父类(接口) 变量赋值。

    父类的引用变量指向子类对象。多态的前提需要有继承关系或者者是实现关系,否则没法完成多态。在使用多态后的父类引用变量调用方法时,会调用子类重写的;

    二、多态的定义与使用

    多态的定义格式:就是父类的引用变量指向子类的对象;

    父类类型变量名 = new 子类对象();

    变量名.方法名();

    1.普通类的多态定义格式:

    父类类型变量名 = new 子类();

    5a238ff88cad95641645f14d618830f3.png

    2.笼统类多态的定义:

    笼统类变量名 =new 笼统类子类();

    b6b7a32882874d130f9bdfcd9615bfc8.png

    3.接口多态定义的格式:

    接口变量名 =new 接口实现类();

    c094a03a819de326b5c2513d4acf6e54.png

    注意:尽管变量指向子类的对象,但体现的是一个父类的形态,可以调用一切父类的方法,子类特有的方法将不能调用

    三、多态调用的注意事项:

    编译:成员变量,成员方法都需要看父类;父类没有编译报错;

    运行:成员变量运行父类的成员变量,成员方法运行父类重写的方法

    四、多态的好处与弊端

    好处:多态配合继承子类重写,提高了代码的复用性与扩展性

    弊端:不能调用子类特有的方法

    五、向上向下类型转换

    多态本身是子类类型向父类类型向上转型的过程;

    1.向上转型:

    当子类的对象赋值给一个父类的引用时,便是向上转型,多态本身就是向上转型的过程

    使用格式:父类类型 变量名= new 子类类型();

    2.向下转型:

    一个已经向上转型的子类对象可以使用强制类型转换的格式,将父类的引用转换为子类引用,这个过程是向下转型。直接创立父类对象的无法使用向下转型;

    使用格式:

    子类类型 变量名= (子类类型) 父类类型的变量;

    六、instanceof 关键字

    可以通过instanceof关键字来判断某个对象能否属于某种数据类型;

    使用格式:

    boolean b= 对象(new ) instanceof 数据类型;

    ?为了让学习变得轻松、高效,今天给大家免费分享一套Java教学资源。帮助大家在成为Java架构师的道路上披荆斩棘。需要资料的欢迎加入学习交流群:9285,05736

    展开全文
  • java 多态调用

    2021-02-25 19:10:44
    ---------- instanceof 判断某个对象是否属于某种数据类型:boolean b = 对象 instanceof 数据类型;如Person p1 = new Student(); // 前提条件,学生类已经继承了人类boolean flag = p1 instanceof Student;...

    1. 调用成员变量:编译、运行都看左边。

    2. 调用成员方法:编译看左边,运行看右边。

    ----------  instanceof 判断某个对象是否属于某种数据类型:

    boolean  b  = 对象  instanceof  数据类型;

    Person p1 = new Student(); // 前提条件,学生类已经继承了人类

    boolean flag = p1 instanceof Student; //flag结果为true

    boolean flag2 = p1 instanceof Teacher; //flag结果为false

    向上转型:当有子类对象赋值给一个父类引用时,便是向上转型,多态本身就是向上转型的过程。

    使用格式:

    父类类型  变量名 = new 子类类型();

    如:Person p = new Student();

    向下转型:一个已经向上转型的子类对象可以使用强制类型转换的格式,将父类引用转为子类引用,这个过程是向下转型。

    目的:调用子类独有的方法;先判断,再转型

    public classDemo03 {public static voidmain(String[] args) {

    Person p=newStudent();//向下转型:调用子类独有的方法

    if(p instanceofStudent){

    Student stu=(Student) p;

    System.out.println(stu.a);

    System.out.println(stu.b);

    stu.study();

    stu.eat();

    }

    }

    }

    如果是直接创建父类对象,是无法向下转型的!

    使用格式:

    子类类型 变量名 = (子类类型) 父类类型的变量;

    如:Student stu = (Student) p;  //变量p 实际上指向Student对象

    展开全文
  • java多态(重要O!)

    2021-03-01 06:15:54
    一、多态的语法关于java语言中的向上转型和向下转型1、向上转型(upcasting):子 -->父2、向下转型(downcasting)父-->子注意:无论向下向上转型,两个类之间一定要有继承关系。举个栗子:父类Animal:public ...

    一、多态的语法

    关于java语言中的向上转型和向下转型

    1、向上转型(upcasting):子 -->父

    2、向下转型(downcasting)父-->子

    注意:无论向下向上转型,两个类之间一定要有继承关系。

    举个栗子:

    父类Animal:

    public class Animal {

    public void eat() {

    System.out.println("eat");

    }

    }

    子类Dog:

    public class Dog extends Animal{

    public void eat() {

    System.out.println("dog eat bone");

    }

    }

    子类Cat:

    public class Cat extends Animal{

    public void eat() {

    System.out.println("cat eat fish");

    }

    // cat 特有的方法

    public void move() {

    System.out.println("cat move");

    }

    }

    测试类Test:

    注意:好好看注释哦 >-<

    public class Test{

    public static void main(String[] args) {

    // 向上转型,又被称作自动类型转换

    // 父类型的引用指向子类型对象

    // 程序分为两个阶段:编译阶段,运行阶段。

    // 程序编译阶段只知道a1是一个Animal类型

    // 程序运行阶段,堆中的实际对象是Cat

    Animal a1 = new Cat();

    // 程序在编译阶段a1被编译器看做Animal类型

    // 所以程序在编译阶段a1引用绑定的是Animal类中的eat方法(静态绑定)

    a1.eat(); // 输出:cat eat fish

    // 程序在运行的时候堆中的对象实际上是Cat类型,而Cat已经重写了eat方法

    // 所以程序在运行阶段,对象的绑定的方法是Cat中的eat方法(动态绑定)

    // 向下转型:强制类型转换

    Animal a2 = new Cat(); // 向上转型

    //要执行move方法,怎么做?

    // a2.move(); 编译不通过(因为在编译期时,系统认为Animal类中没有move方法)

    // 所以要强制类型转换,需要加强制类型转换符

    Cat c1 = (Cat)a2;

    c1.move(); // 输出:cat move

    // 判断一下程序运行时出现什么问题?

    // Animal a3 = new Dog(); // 向上转型

    //

    // 强制类型转换

    // Cat c2 = (Cat)a3; // java.lang.ClassCastException类型转换异常

    //在做强制类型转换时,程序是存在风险的!

    // 为了避免ClassCastException的发生,java引入了instanceof

    /*

    用法:

    1、instanceof运算符的运算结果是boolean类型

    2、(引用 instanceof 类型) --> true/false

    例如: (a instanceof Cat)如果结果是true表示:a指向堆中的java对象是Cat类型

    */

    Animal a3 = new Dog();

    // 推荐:在向下转型的时候要使用instanceof运算符判断,避免ClassCastException

    if(a3 instanceof Cat) { // false

    Cat c2 = (Cat)a3; // 没执行哦

    }

    }

    }

    再次强调:

    instanceof用法:

    1、instanceof运算符的运算结果是boolean类型

    2、(引用 instanceof 类型) --> true/false

    例如: (a instanceof Cat)如果结果是true表示:a指向堆中的java对象是Cat类型

    二、多态的好处

    我们先举栗子:

    模拟主人投喂宠物:

    测试类Test

    public class Test{

    public static void main(String [] args) {

    // 1、创建主人

    Person hl = new Person();

    // 2、创建宠物

    Dragon d = new Dragon();

    Fox f = new Fox();

    // 3、喂养

    hl.feed(d);

    hl.feed(f);

    // 我们发现:person类型的扩展能力太差

    }

    }

    主人Person类:

    public class Person {

    // 喂养

    public void feed(Dragon d) {

    d.eat();

    }

    public void feed(Fox f) {

    f.eat();

    }

    宠物Dragon类:

    public class Dragon{

    public void eat() {

    System.out.println("Dragon eat");

    }

    }

    宠物Fox类:

    public class Fox extends Animal{

    public void eat() {

    System.out.println("fox eat");

    }

    }

    输出:Dragon eat fox eat

    评价:通过此例子,我们发现,主人person每增加一个宠物都会使用一次feed()并传递对象,使代码的耦合度提高,扩展能力差。

    我们使用多态来解决这个问题:

    测试类Test

    public class Test{

    public static void main(String [] args) {

    // 1、创建主人

    Person hl = new Person();

    // 2、创建宠物

    Dragon d = new Dragon();

    Fox f = new Fox();

    // 3、喂养

    hl.feed(d);

    hl.feed(f);

    }

    }

    主人Person类:

    public class Person {

    public void feed(Animal a) { // Animal a = d or f 多态哦!

    a.eat();

    }

    // 尽量不要面向具体编程,面向父类编程,面向抽象编程

    }

    父类Animal:

    public class Animal {

    public void eat() {

    }

    }

    子类Dragon

    public class Dragon extends Animal{

    public void eat() {

    System.out.println("Dragon eat");

    }

    }

    子类Fox

    public class Fox extends Animal{

    public void eat() {

    System.out.println("fox eat");

    }

    }

    输出:Dragon eat

    fox eat

    总结多态的作用:

    1、使用多态可以使代码之间的耦合度降低

    2、项目的扩展能力增强

    38811272b19b

    sky

    展开全文
  • 下面要给大家分享的是几个比较经典也很简单的java多态例题,感兴趣的小伙伴可以一起来通过下面的文章了解一下,对于java面试还是很有帮助的呢。1、多态分类多态分成了2种,一个是编译时多态,另外一个是运行时多态。...

    下面要给大家分享的是几个比较经典也很简单的java多态例题,感兴趣的小伙伴可以一起来通过下面的文章了解一下,对于java面试还是很有帮助的呢。

    1、多态分类

    多态分成了2种,一个是编译时多态,另外一个是运行时多态。

    编译时多态-方法重载。

    2、运行时多态存在的三个必要条件是什么?

    (1)、要有继承,还包括了接口的实现

    (2)、要有重写

    (3)、父类引用指向子类对象

    3、多态的好处是什么?

    主要有五大好处,分别是可替换性、可扩充性、接口性、灵活性、简化性。

    分别介绍一下,多态对已经存在代码具有可替换性,例如,多态对圆Circle类工作,对其他任何圆形几何体,如圆环,也同样工作;多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性,以及其他特性的运行和操作,实际上新加子类更容易获得多态功能,例如,在实现了圆锥、半圆锥以及半球体的多态基础上,很容易增添球体类的多态性;多态是超类通过方法签名,向子类提供了一个共同接口,由子类来完善或者覆盖它而实现的;多态在应用中体现了灵活多样的操作,提高了使用效率;多态简化对应用软件的代码编写和修改过程,尤其在处理大量对象的运算和操作的时候,这个特点尤为突出和重要;

    4、题目package arithmetic;

    public class duotai

    {

    class A

    {

    public String show(D obj)

    {

    return ("A and D");

    }

    public String show(A obj)

    {

    return ("A and A");

    }

    }

    class B extends A

    {

    // B可以重写A

    public String show(B obj)

    {

    return ("B and B");

    }

    // 重写A方法了吗?

    public String show(A obj)

    {

    return ("B and A");

    }

    }

    class C extends B

    {}

    class D extends B

    {}

    public static void main(String[] args)

    {

    duotai outerclass = new duotai();

    A a1 = outerclass.new A();

    A a2 = outerclass.new B();

    B b = outerclass.new B();

    C c = outerclass.new C();

    D d = outerclass.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、a1是A类的一个实例化对象,所以this指向A,之后查找this.show(b),因为,没有这个方法,所以到super.show(b),可是因为A类没有超类了,所以到this.show(super

    b),因为,b的超类是A,所以相当于this.show(A),然后在A类中查找到了这个方法,所以输出A and A。

    2、a1是A类的实例化对象,所以this指向A,之后,在A类中查找this.show(C)方法,因为,没有这个方法,所以到了super.show(C),由于A类的超类里面找,可是,A没有超类,所以到了this.show(super

    C),因为,C的超类是B所以在A类里面查找this.show(B)方法,也没找到,之后,B也有超类,就是A,所以查找this.show(A),找到了,所以,输出A

    and A;

    3、a1是A类的实例化对象,所以this指向A,之后,在A类中找到this.show(D)方法,找到了,所以就输出A and D;

    4、a2是B类的引用对象,类型为A,所以this指向A类,之后,在A类里面找this.show(B)方法,没有找到,所以到了super.show(B),由于A类没有超类,所以到了this.show(super

    B),B的超类是A,也就是super B =

    A,所以执行方法this,show(A),在A方法里面找show(A),找到了,可是,因为a2是一个类B的引用对象,B类里面覆盖了A类的show(A)方法,所以最终执行的是B类里面的show(A)方法,所以,输出B

    and A;

    5、a2是B类的引用对象,类型为A,所以this指向A类,之后,在A类里面找this.show(C)方法,没有找到,所以到了super.show(C)方法,因为,A类没有超类,所以到了this.show(super

    C),C的超类是B,所以在A类里面找show(B),同样没有找到,发现B还有超类,也就是A,所以还继续在A类里面找show(A)方法,找到了,可是,因为a2是一个类B的引用对象,而B类里面覆盖了A类的show(A)方法,所以最终执行的是B类里面的show(A)方法,所以,输出B

    and A;

    6、a2是B类的引用对象,类型为A,所以this指向A类,之后,在A类里面找this.show(D)方法,找到了,可是因为,a2是一个类B的引用对象,所以在B类里面查找有没有覆盖show(D)方法,没有,所以执行的是A类里面的show(D)方法,所以输出A

    and D;

    7、b是B类的一个实例化对象,首相执行this.show(B),在B类里面找show(B)方法,找到了,直接输出B and B;

    8、b是B类的一个实例化对象,首相执行this.show(C),在B类里面找show(C)方法,没有找到,所以到了super.show(c),B的超类是A,所以在A类中找show(C)方法,没有找到,于是到了this.show(super

    C),C的超类是B,所以在B类中找show(B)f方法,找到了,所以执行B类中的show(B)方法输出B and B;

    9、b是B类的一个实例化对象,首相执行this.show(D),在B类里面找show(D)方法,没有找到,所以,到了super.show(D),B的超类是A类,所以在A类里面找show(D)方法,找到了,所以输出A

    and D;

    很多人说对于java面试都会很紧张,可是,只要你做好了充分的准备,有了底气那么这些应该都不是问题,建议大家在去面试之前,多看一些java面试题和面经,这样对你的面试会有很大的帮助哦。

    推荐阅读:

    展开全文
  • 面向对象编程有三个特征,即封装、继承和多态。封装隐藏了类的内部实现机制,从而可以在不影响使用者的前提下改变类的内部结构,同时保护了数据。继承是为了重用父类代码,同时为实现多态性作准备。那么什么是多态呢...
  • java多态

    2021-02-12 09:20:29
    1.多态的概述:是面向对象的三大特性之...②Java多态的代码体现在一个子类对象(实现类对象)既可以给这个子类(实现类对象)引用变量赋值,又可以给这个子类(实现类对象)的父类(接口)变量赋值。普通类与普通类,抽象...
  • 多态是继封装、继承之后,面向对象的第三大特性。现实事物经常会体现出多种形态,如学生,学生是人的一种,则一个具体的同学张三...Java多态的代码体现在一个子类对象(实现类对象)既可以给这个子类(实现类对象)引...
  • Java多态

    2021-04-23 19:43:37
    1. 简介学过 Java 的人都会遇到过这样的问题:面向对象的三个基本特征是什么?答案是封装、继承、多态。可见多态在面向对象程序设计中的重要地位。但是我们真地深入思考过多态吗,多态是什么?怎么样达到多态多态...
  • java多态的特点?

    2021-02-12 20:45:44
    展开全部多态是同一个行为具有多个不同表现形式或形态的能力。多态性是对象多种表现形式的体现。比如62616964757a686964616fe4b893e5b19e31333335336463我们说"宠物"这个对象,它就有很多不同的表达或实现,比如有...
  • 大家好,本文将会给大家带来Java多态。以上就是本次学习的6大任务。我们依次来看。1 Object类Object类是所有Java类的根基类。如果在类的声明中未使用extends关键字指明其基类,则默认基类为Object类。class Person{}...
  • java多态(一)

    2021-03-17 12:00:45
    /* Son1 class grammar.Son1 Son2 class grammar.Son2 */ //由此可见,父类的doSomething方法多态地调用了我们传递的对象的getName方法,而不是Parent类本身的getName方法。 } } class Son1 extends Parent { ...
  • 下面要给大家分享的是一个多态经典案例,一起来看看这个java多态简单例子吧。/*多态的好处:提高了代码的维护性和扩展性;弊端:父类不能使用子类的特有功能。要用子类的特有功能,可以:A:创建子类对象,调用方法...
  • Java动态多态原理

    2021-02-27 13:02:57
    很多书本说到多态,概念就把人看晕了,本人从实际使用角度,来介绍多态,希望对大家有用。什么是多态多态简单来说,就是调用同一个函数名字,会出现不同的运行结果。多态分为几种:多态分为静态多态、动态多态什么...
  • Java多态的实现机制是什么Java中实现多态的机制是依靠父类或接口的引用指向子类,从而实现一个对象多种形态的特性,其父类的引用是在运行时动态的指向具体的实例,调用该引用的方法时,不是根据引用变量的类型中定义...
  • 多态存在要有3个必要条件:继承、方法重写、父类引用指向子类对象。3.父类引用指向子类对象后,用该父类引用调用子类重写的方法,此时多态就出现了。案例代码:package com.jackfujia.oo2;/*** 测试多态* @author ...
  • Java多态的用法

    2021-02-28 18:07:30
    一、什么是多态一个父类的引用类型变量它既可以指向父类对象也可以指向子类对象,它可以根据当前时刻指向的不同,自动调用不同对象的方法,这就是多态。如果 学了C语言的指针,我觉得多态还是比较好理解的,就好比...
  • }}下面这个例子就是重写,他实现了多态~~重写的要求是,方法名必须一样,返回类型必须一样,传入的参数必须一样在main函数中定义父类的对象,但是用子类去实例化他,这样就可以通过父类的对象调用到子类的方法。...
  • 首先,我们需要知道的是,java多态的实现机制是父类或接口定义的引用变量可以指向子类或实现类的实例对象,而程序调用的方法在运行期才动态绑定,就是引用变量所指向的具体实现对象的方法,也就是内存里正在运行的...
  • java多态的概念

    2021-02-13 01:44:37
    多态:父类型的引用可以指向子类型的对象。比如 Parent p = newChild();当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,再去调用子类的该同名方法。(注意此处,静态static...
  • 对于java中的多态你是怎样理解的呢?很多人表示,自己对于多态的概念...延伸阅读2、java多态的使用场景介绍方法的重写和重载、子类对象的多态性;使用前提-有类的继承、由子类对父类方法的重写;使用方式-通过父类...
  • 一、多态多态分为两种:(1)引用的多态、(2)方法的多态引用的多态:父类的引用可以指向本类的对象;父类的引用可以指向子类的对象;注意:子类的对象不可以指向父类的对象,如下图所示方法的多态:创建本类对象时,...
  • Java多态总结

    2021-03-10 09:50:49
    这篇可能是今年最后一篇总结类的博文了,希望能够写的好点吧 _至此,博客中java基础方面的内容零零散散地也逐渐总结完了,基本上面试经常问到的内容都涵盖了,希望大家喜欢概念介绍定义多态,是面向对象的程序设计...
  • I'm a little confused exactly about how polymorphism and extending classes etc... works in Java when creating objects from these classes.I recently had a problem which someone on here helped me resolv...
  • java多态值得注意的小细节 首先,JVM特性 : 多线程,跨平台,面向对象,自动垃圾回收机制 面向对象特性 : 封装性,继承性,动态性(多态),抽象 多态相关知识点 : 软件设计六大原则 里氏替换原则 : 能够使用父类的地方就...
  • 通俗易懂的了解java多态 还是要坚持学习啊 各种原因,一年多没写过博客了。疫情期间,在家隔离。还是要学习啊。定个目标,以后每周最少写一篇博客。记录学习,记录工作,记录生活! 什么是多态? 接下来我们来看看...
  • java多态是重要的知识点,我们一定要清楚的,而java多态内存分析相对会比较难,在这里给大家提供了多态的内存分析图实例,希望可以给您带来帮助!定义动物类animal.java作为父类。package cn.bjsxt.oop.polymorphism...
  • 如何理解Java面向对象多态特征什么是多态呢?按字面意思来讲,多态即多种状态,在面向对象语言中,接口的多种不同的实现方式即为多态多态,是面向对象的程序设计语言最核心的特征。Java多态的定义指允许不同类...
  • super.method((super)o)这个顺序以及多态的详解可以参看一个经典实例理解java的三大特性之多态我在拜读这篇文章的时候很是赞赏,但是后来自己实践时发现了一些不一样的地方,于是在这里拉出来讨论。我在写方法时使用...
  • java的面向对象中可以从以下两个方面来讲。01不同子类之间的多态在前面我们说继承的时候说到,子类可以继承到父类的方法,继承后可以对方法进行重写。这个时候就会有不同的子类重写的功能是不同的。我们来举个例子...
  • 什么是多态JAVA多态 方法必须要被所在类或对象调用才有意义 若方法含有参数: 形参:方法声明时的参数。 实参:方法调用时实际传给形参的参数值。 JAVA里将实参数值传入方法的传递机制只有 值传递 在值...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 201,317
精华内容 80,526
关键字:

java对象多态

java 订阅