精华内容
下载资源
问答
  • java多态练习题

    2018-04-21 17:52:18
    java多态、继承练习题,包含题目与答案,............................................................................................................
  • java多态理解

    2018-12-17 14:10:05
    java 个人对于多态理解和一些笔记。
  • JAVA多态图文详解ppt

    2018-03-20 16:46:02
    JAVA多态图文详解ppt,详细通过各种举例介绍JAVA多态的ppt
  • Java多态的讲解

    2017-07-01 20:10:36
    Java多态的讲解
  • 这边文章的编程代码:https://blog.csdn.net/qq_41086359/article/details/103650238 Java多态,面向对象编程题
  • java 多态实例

    2015-08-25 15:24:39
    一个简单的多态实例,包含interface,abstract class 以及两种排序方式
  • 下面小编就为大家带来一篇浅谈java多态的实现主要体现在哪些方面。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • java多态机制

    2015-08-07 14:32:27
    java的多态机制的讲解,重写,重载,子类父类的继承 java多态的应用
  • java 多态实例代码

    2020-08-28 09:04:15
    主要介绍了java 多态实例代码,具有一定借鉴价值,需要的朋友可以参考下
  • Java多态的内存机制

    2020-12-22 17:22:43
     1:java面向对象特征:抽象,封装,继承,多态。  抽象:  封装:  继承:  多态:  写一个类,来完成以上所包含的抽象,封装,继承内容   class LaoYin extends Thread implements ...
  • 下面要给大家分享的是一个多态经典案例,一起来看看这个java多态简单例子吧。/*多态的好处:提高了代码的维护性和扩展性;弊端:父类不能使用子类的特有功能。要用子类的特有功能,可以:A:创建子类对象,调用方法...

    下面要给大家分享的是一个多态经典案例,一起来看看这个java多态简单例子吧。/*多态的好处:提高了代码的维护性和扩展性;

    弊端:父类不能使用子类的特有功能。

    要用子类的特有功能,可以:

    A:创建子类对象,调用方法即可(不合理,太占内存);

    B:把父类的引用强制转换为子类的引用(向下转型);

    向上转型:Fu f = new Zi();

    向下转型:Zi z = (Zi) f;//要求该f必须是转换为Zi的。

    */

    class Animal

    {

    public void eat()

    {

    System.out.println("吃饭");

    }

    }

    class Dog extends Animal

    {

    public void eat()

    {

    System.out.println("狗吃肉");

    }

    public void lookDoor()

    {

    System.out.println("狗看门");

    }

    }

    class Cat extends Animal

    {

    public void eat()

    {

    System.out.println("猫吃鱼");

    }

    public void playGame()

    {

    System.out.println("捉迷藏");

    }

    }

    public class DuoTaiTest

    {

    public static void main(String[] args)

    {

    //定义为狗

    Animal a = new Dog();

    a.eat();

    System.out.println("------------");

    //还原成狗

    Dog d = (Dog) a;

    d.eat();

    d.lookDoor();

    System.out.println("-------------");

    //变成猫

    a = new Cat();

    a.eat();

    System.out.println("-------------");

    //还原成猫

    Cat c = (Cat) a;

    c.eat();

    c.playGame();

    }

    }

    运行的结果

    0480f6e2f70bc8a191636dc133e37b50.png

    上面这个简单的java多态举例,你都仔细的看了吗?你还想了解更多的java经典实例吗?请继续关注奇Q工具网的java实例栏目来了解吧。

    推荐阅读:

    展开全文
  • Java 多态

    2021-03-09 09:03:24
    一、多态定义多态就是指对象的多种形态。一个是引用的多态;一个是方法的多态。1、引用多态当我们在写面向对象程序的时候,一般父类的引用可以指向本类的对象。Animal a = new Animal(); //a是父类的引用指向的是本...

    一、多态定义

    多态就是指对象的多种形态。一个是引用的多态;一个是方法的多态。

    1、引用多态

    当我们在写面向对象程序的时候,一般父类的引用可以指向本类的对象。

    Animal a = new Animal(); //a是父类的引用指向的是本类的对象

    Animal b = new Dog(); //b是父类的引用指向的是子类的对象

    //注意:我们不能使用一个子类的引用去指向父类的对象

    2、方法多态

    一般情况下,我们都是用本类的对象,调用本类的方法。在多态中,创建子类对象时,调用的方法为子类重写的方法或继承的方法。

    Animal a = new Animal(); //a是父类的引用指向的是本类的对象

    Animal b = new Dog(); //b是父类的引用指向的是子类的对象

    //这边是引用的多态

    a.bark(); //调用的是父类Animal的方法

    b.bark(); //调用的是子类Dog重写的方法

    //这便是方法的多态

    注意:

    父类分引用指向子类对象时不可以调用子类独有的方法,只能调用继承或重写的方法

    引用多态不能使用一个子类的引用去指向父类的对象

    抽象类在定义类时,前面会加abstract关键字。那我们什么时候会用到抽象类呢?

    在某些情况下,某个父类只是知道其子类应该包含怎样的方法,但无法准确知道这些子类如何实现这些方法。也就是说抽象类是约束子类必须要实现哪些方法,而并不关注方法如何去实现。

    抽象类在定义类时,前面会加abstract关键字。那我们什么时候会用到抽象类呢?

    在某些情况下,某个父类只是知道其子类应该包含怎样的方法,但无法准确知道这些子类如何实现这些方法。也就是说抽象类是约束子类必须要实现哪些方法,而并不关注方法如何去实现。

    二、多态引用类型转换

    Dog a = new Dog();

    Animal b = a; //自动类型提升 向上类型转换(无风险)

    /*

    Dog c = b;

    //将父类引用转换成子类引用,编译器不允许这样做

    */

    Dog c = (Dog)b; //在父类前加上小括号,里面加上子类类型,实现强制转换

    //向下类型转换

    /*

    Cat d = (Cat)b;

    //虽然编译器不会报错,但运行会出问题,因为b是指向Dog类的,它们是不同类型的对象,这里就存在风险

    /*

    三、 抽象类

    从多个具有相同特征的类中抽象出一个抽象类,以这个抽象类作为子类的模板,从而避免了子类设计的随意性。

    抽象类是限制规定子类必须实现某些方法,但不关注实现细节。

    那抽象类如何用代码实现呢,它的规则如下:

    用 abstract 修饰符定义抽象类

    用 abstract 修饰符定义抽象方法,只用声明,不需要实现

    包含抽象方法的类就是抽象类

    抽象类中可以包含普通的方法,也可以没有抽象方法

    抽象类的对象不能直接创建,我们通常是定义引用变量指向子类对象。

    aee20a3271bb36a098da4173511a1589-wm

    091cd2b9e4f2cce16b6da2c215728ed7-wm

    展开全文
  • Java多态

    2021-02-25 20:12:27
    关于多态的一段代码public class test {public static void main(String[] args) {show(new Cat()); // 以 Cat 对象调用 show 方法show(new Dog()); // 以 Dog 对象调用 show 方法Animal a = new Cat(); // 向上转型...

    关于多态的一段代码

    public class test {

    public static void main(String[] args) {

    show(new Cat()); // 以 Cat 对象调用 show 方法

    show(new Dog()); // 以 Dog 对象调用 show 方法

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

    a.eat(); // 调用的是 Cat 的 eat

    Cat c = (Cat) a; // 向下转型

    c.work(); // 调用的是 Cat 的 work

    }

    public static void show(Animal a) {

    a.eat();

    // 类型判断

    if (a instanceof Cat) { // 猫做的事情

    Cat c = (Cat) a;

    c.work();

    } else if (a instanceof Dog) { // 狗做的事情

    Dog c = (Dog) a;

    c.work();

    }

    }

    }

    abstract class Animal {

    abstract void eat();

    }

    class Cat extends Animal {

    public void eat() {

    System.out.println("吃鱼");

    }

    public void work() {

    System.out.println("抓老鼠");

    }

    }

    class Dog extends Animal {

    public void eat() {

    System.out.println("吃骨头");

    }

    public void work() {

    System.out.println("看家");

    }

    }

    输出结果:

    吃鱼

    抓老鼠

    吃骨头

    看家

    吃鱼

    抓老鼠

    虚函数

    虚函数的存在是为了多态。

    Java 中其实没有虚函数的概念,它的普通函数就相当于 C++ 的虚函数,动态绑定是Java的默认行为。如果 Java 中不希望某个函数具有虚函数特性,可以加上 final 关键字变成非虚函数。

    重写

    Employee.java代码

    /* 文件名 : Employee.java */

    public class Employee {

    private String name;

    private String address;

    private int number;

    public Employee(String name, String address, int number) {

    System.out.println("Employee 构造函数");

    this.name = name;

    this.address = address;

    this.number = number;

    }

    public void mailCheck() {

    System.out.println("邮寄支票给: " + this.name

    + " " + this.address);

    }

    public String toString() {

    return name + " " + address + " " + number;

    }

    public String getName() {

    return name;

    }

    public String getAddress() {

    return address;

    }

    public void setAddress(String newAddress) {

    address = newAddress;

    }

    public int getNumber() {

    return number;

    }

    }

    假设下面的类继承Employee类

    /* 文件名 : Salary.java */

    public class Salary extends Employee {

    private double salary; // 全年工资

    public Salary(String name, String address, int number, double salary) {

    super(name, address, number);

    setSalary(salary);

    }

    public void mailCheck() {

    System.out.println("Salary 类的 mailCheck 方法 ");

    System.out.println("邮寄支票给:" + getName()

    + " ,工资为:" + salary);

    }

    public double getSalary() {

    return salary;

    }

    public void setSalary(double newSalary) {

    if (newSalary >= 0.0) {

    salary = newSalary;

    }

    }

    public double computePay() {

    System.out.println("计算工资,付给:" + getName());

    return salary / 52;

    }

    }

    VirtualDemo.java代码

    /* 文件名 : VirtualDemo.java */

    public class VirtualDemo {

    public static void main(String[] args) {

    Salary s = new Salary("员工 A", "北京", 3, 3600.00);

    Employee e = new Salary("员工 B", "上海", 2, 2400.00);

    System.out.println("使用 Salary 的引用调用 mailCheck -- ");

    s.mailCheck();

    System.out.println("\n使用 Employee 的引用调用 mailCheck--");

    e.mailCheck();

    }

    }

    运行结果:

    Employee 构造函数

    Employee 构造函数

    使用 Salary 的引用调用 mailCheck --

    Salary 类的 mailCheck 方法

    邮寄支票给:员工 A ,工资为:3600.0

    使用 Employee 的引用调用 mailCheck--

    Salary 类的 mailCheck 方法

    邮寄支票给:员工 B ,工资为:2400.0

    多态的实现

    重写

    借口

    抽象类和抽象方法

    多态的分类

    多态一般分为两种:重写式多态和重载式多态。

    重载式多态,也叫编译时多态。也就是说这种多态再编译时已经确定好了。重载大家都知道,方法名相同而参数列表不同的一组方法就是重载。在调用这种重载的方法时,通过传入不同的参数最后得到不同的结果。

    但是这里是有歧义的,有的人觉得不应该把重载也算作多态。因为很多人对多态的理解是:程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,这种情况叫做多态。 这个定义中描述的就是我们的第二种多态—重写式多态。并且,重载式多态并不是面向对象编程特有的,而多态却是面向对象三大特性之一(如果我说的不对,记得告诉我。。)。

    我觉得大家也没有必要在定义上去深究这些,我的理解是:同一个行为具有多个不同表现形式或形态的能力就是多态,所以我认为重载也是一种多态,如果你不同意这种观点,我也接受。

    重写式多态,也叫运行时多态。这种多态通过动态绑定(dynamic binding)技术来实现,是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法。也就是说,只有程序运行起来,你才知道调用的是哪个子类的方法。 这种多态通过函数的重写以及向上转型来实现,我们上面代码中的例子就是一个完整的重写式多态。我们接下来讲的所有多态都是重写式多态,因为它才是面向对象编程中真正的多态。

    JAVA – 虚函数、抽象函数、抽象类、接口

    1. Java 虚函数

    虚函数的存在是为了多态。

    C++ 中普通成员函数加上 virtual 关键字就成为虚函数。

    Java 中其实没有虚函数的概念,它的普通函数就相当于 C++ 的虚函数,动态绑定是 Java 的默认行为。如果 Java 中不希望某个函数具有虚函数特性,可以加上 final 关键字变成非虚函数。

    PS: 其实 C++ 和 Java 在虚函数的观点大同小异,异曲同工罢了。

    2. Java抽象函数(纯虚函数)

    抽象函数或者说是纯虚函数的存在是为了定义接口。

    C++ 中纯虚函数形式为:

    virtual void print() = 0;

    Java 中纯虚函数形式为:

    abstract void print();

    PS: 在抽象函数方面 C++ 和 Java 还是换汤不换药。

    3. Java 抽象类

    抽象类的存在是因为父类中既包括子类共性函数的具体定义,也包括需要子类各自实现的函数接口。抽象类中可以有数据成员和非抽象方法。

    C++ 中抽象类只需要包括纯虚函数,既是一个抽象类。如果仅仅包括虚函数,不能定义为抽象类,因为类中其实没有抽象的概念。

    Java 抽象类是用 abstract 修饰声明的类。

    PS: 抽象类其实是一个半虚半实的东西,可以全部为虚,这时候变成接口。

    4. Java 接口

    接口的存在是为了形成一种规约。接口中不能有普通成员变量,也不能具有非纯虚函数。

    C++ 中接口其实就是全虚基类。

    Java 中接口是用 interface 修饰的类。

    PS: 接口就是虚到极点的抽象类。

    5. 小结

    C++ 虚函数 == Java 普通函数

    C++ 纯虚函数 == Java 抽象函数

    C++ 抽象类 == Java 抽象类

    C++ 虚基类 == Java 接口

    展开全文
  • 下面要给大家分享的是几个比较经典也很简单的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-03-16 15:53:29
    大家都知道java有三大特性就是封装,继承和多态 今天我们要说的就是其中的多态什么是多态定义多态是面向对象程序设计语言最核心的特征,意味着一个对象有着多重特征,可以在特定的情况下表现不同的状态从而对应不同...
  • java 多态

    2020-05-19 13:43:02
    java 多态
  • Java多态经典例题

    千次阅读 2020-10-15 10:17:47
    } } } A:6 6 7 B:22 34 17 c:22 74 74 D:11 17 34 思路分析一: 思考和解决这个题的主要核心在于对java多态的理解。个人理解时,执行对象实例化过程中遵循多态特性 ==> 调用的方法都是***将要实例化的子类中***的...
  • 浅析Java多态

    2020-12-11 22:49:11
    Java多态 今天来谈谈Java中的多态,作为面向对象的一大特性,它的重要性不必多说,相比其他两特性(继承、封装)从字面上看就有点不易读懂,多种态度还是有多变态? 官解 官方解释: 多态是同一个行为具有多个不同...
  • java 多态的意义

    2021-03-10 09:50:19
    java 多态的意义在实际操作中,多态可以让我们不用关心某个对象到底是什么具体类型,就可以使用该对象的某些方法,而这些方法通过一个抽象类或者接口来实现,多态就是提供父类调用子类代码的一个手段而已。...
  • Java多态的实现原理

    2021-02-12 12:54:07
    0.前言多态Java技术里有很重要的地位,在面试中也会经常被问到。多态的使用大家应该都比较了解,但是多态的实现原理就有点抽象了,查了很多很多资料,连续几天断断续续的看,有时候看着看着就走神了。毕竟太抽象...
  • java 多态调用

    2021-02-25 19:10:44
    //flag结果为false 向上转型:当有子类对象赋值给一个父类引用时,便是向上转型,多态本身就是向上转型的过程。 使用格式: 父类类型 变量名 = new 子类类型(); 如:Person p = new Student(); 向下转型:一个已经...
  • 相信很多学习java的人对于java多态是非常了解的,它的知识点也是非常重要的。今天就来为大家介绍一下,java多态是什么意思?并且用实例分享出来,一起来了解一下吧。首先,多态指同一个实体同时具有多种形式。它是...
  • 原文出自...这一原则也适用于面向对象的编程语言如Java语言。子类可以定义自己独特的行为,并共享父类一些相同的功能。多态可以通过Bicycle类的修改进行展示。例如,可以添加一个printDescri...
  • Java 多态的例子

    2021-03-15 14:49:54
    多态就是通过继承和动态绑定来决定程序使用哪个实现.一个简单的例子。interface Animal {public void eat();}class Whale extends SeaAnimal {int age = 20;@Overridepublic void eat() {System.out.println("Whale ...
  • java多态简单例子详解

    2021-02-27 20:52:11
    java多态简单例子:首先有一个Animal类,它有Cat,和Dog两个子类;然后在Animal中有个say方法,当Cat调用这个方法的时候输出的是“小猫喵喵喵”,当Dog调用这个方法时,输出的是“小狗汪汪汪”。【相关学习推荐:...
  • Java多态面试题汇总含答案

    千次阅读 2021-02-26 18:14:27
    本文为大家整理汇总了,近年来比较常见且典型的Java多态面试题。当然,本次对面试题的总结整理,更加注重大家对于多态知识的掌握,而不仅仅只是对面试的应付。每道面试题后面都会附上相关问题的答案和分析,让大家...
  • 分享java多态简单例子

    2021-02-28 19:02:33
    java多态简单例子:首先创建接口;然后需要创建两个类来确定说话内容;接着需要在说话的同时打印时间;最后创建测试类运行即可。java多态简单例子:多态的三大必要条件(实现):需要有继承(继承类,继承抽象类,实现...
  • java多态的讲解

    2018-08-06 21:38:04
    用代码实例和注释向你讲述什么是多态,实例更容易理解
  • 经典Java多态例子

    2020-10-26 18:30:00
    经典Java多态例子@白兴华 Java 多态 多态是Java的基础,学好,理解好多态有助于我们理解Java的其他的知识点 定义 多态是同一个行为具有多个不同的表现形式或形态的能力 多态的优点 1.消除类型之间的耦合关系 2.可...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 234,737
精华内容 93,894
关键字:

java多态

java 订阅
友情链接: cuda-GPU.rar