精华内容
下载资源
问答
  • /*对象的多态性。class 动物{}class 猫 extends 动物{}class 狗 extends 动物{}猫 x = new 猫();动物 x = new 猫();//一个对象,两种形态。猫这类事物即具备者猫的形态...多态的好处:提高了代码的扩展性,前期定义...

    /*

    对象的多态性。

    class 动物

    {}

    class 猫 extends 动物

    {}

    class 狗 extends 动物

    {}

    猫 x = new 猫();

    动物 x = new 猫();//一个对象,两种形态。

    猫这类事物即具备者猫的形态,又具备着动物的形态。

    这就是对象的多态性。

    简单说:就是一个对象对应着不同类型.

    多态在代码中的体现:

    父类或者接口的引用指向其子类的对象。

    多态的好处:

    提高了代码的扩展性,前期定义的代码可以使用后期的内容。

    多态的弊端:

    前期定义的内容不能使用(调用)后期子类的特有内容。

    多态的前提:

    1,必须有关系,继承,实现。

    2,要有覆盖。

    */

    abstract class Animal

    {

    abstract void eat();

    }

    class Dog extends Animal

    {

    void eat()

    {

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

    }

    void lookHome()

    {

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

    }

    }

    class Cat extends Animal

    {

    void eat()

    {

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

    }

    void catchMouse()

    {

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

    }

    }

    class Pig extends Animal

    {

    void eat()

    {

    System.out.println("饲料");

    }

    void gongDi()

    {

    System.out.println("拱地");

    }

    }

    class DuoTaiDemo

    {

    public static void main(String[] args)

    {

    //  Cat c = new Cat();

    //  c.eat();

    //  c.catchMouse();

    Animal a = new Cat(); //自动类型提升,猫对象提升了动物类型。但是特有功能无法s访问。

    //作用就是限制对特有功能的访问。

    //专业讲:向上转型。将子类型隐藏。就不用使用子类的特有方法。

    //  a.eat();

    //如果还想用具体动物猫的特有功能。

    //你可以将该对象进行向下转型。

    //  Cat c = (Cat)a;//向下转型的目的是为了使用子类中的特有方法。

    //  c.eat();

    //  c.catchMouse();

    //  注意:对于转型,自始自终都是子类对象在做着类型的变化。

    //  Animal a1 = new Dog();

    //  Cat c1 = (Cat)a1;//ClassCastException

    /*

    Cat c = new Cat();

    //  Dog d = new Dog();

    //  c.eat();

    method(c);

    //  method(d);

    //  method(new Pig());

    */

    method(new  Dog());

    }

    public static void method(Animal a)//Animal a = new Dog();

    {

    a.eat();

    if(a instanceof Cat)//instanceof:用于判断对象的具体类型。只能用于引用数据类型判断

    //      //通常在向下转型前用于健壮性的判断。

    {

    Cat c = (Cat)a;

    c.catchMouse();

    }

    else if(a instanceof Dog)

    {

    Dog d = (Dog)a;

    d.lookHome();

    }

    else

    {

    }

    }

    /*

    public static void method(Cat c)

    {

    c.eat();

    }

    public static void method(Dog d)

    {

    }

    */

    }

    展开全文
  • Java 多态的好处

    千次阅读 2016-11-19 10:58:20
    什么是多态 面向对象的三大特性:封装、继承、多态。从一定角度来看,封装和继承几乎都是为多态而...实现多态的技术称为:动态绑定(dynamic binding),是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用

    什么是多态

    1. 面向对象的三大特性:封装、继承、多态。从一定角度来看,封装和继承几乎都是为多态而准备的。这是我们最后一个概念,也是最重要的知识点。
    2. 多态的定义:指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用)
    3. 实现多态的技术称为:动态绑定(dynamic binding),是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法。
    4. 多态的作用:消除类型之间的耦合关系。
    5. 现实中,关于多态的例子不胜枚举。比方说按下 F1 键这个动作,如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档;如果当前在 Word 下弹出的就是 Word 帮助;在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不同的对象上会产生不同的结果。

    多态存在的三个必要条件

    • 要有继承
    • 要有重写
    • 父类引用指向子类对象
    package dd20161114_2;
    /**
    父类pet
    */
    public class Pet {
        public  void eat() {
            System.out.println("吃饭");
        }
    }
    
    
    package dd20161114_2;
    
    public class Dog extends Pet {
        public  void eat() {
            // TODO Auto-generated method stub
            System.out.println("狗啃骨头");
            this.hight=5;
        }
    }
    
    package dd20161114_2;
    
    public class Cat extends Pet{
        public  void eat() {
            // TODO Auto-generated method stub
            System.out.println("猫吃鱼");
        }
    }

    三个类,Dog和Cat分别继承了Pet类

    package dd20161114_2;
    
    public class Master1 {
    public static void main(String[] args) {
        //dog对象实例化
            Dog dog=new Dog();
            eat(dog);
        //cat对象实例化
            Cat cat=new Cat();
            eat(cat);
        //Pet对象实例化
            Pet pet=new Dog();
            pet=new Cat();
            eat(pet);
    
        }
        public static void eat(Pet pet){
    
            pet.eat();
        }
    }

    输出结果:
    狗啃骨头
    猫吃鱼
    猫吃鱼
    从输出结果中可以看出,eat方法需要传递的参数为Pet的一个对象,但是当我传递它的子类的时候也可以,而且调用了相应的方法。我还可以通过实例化子类对象获得父类声明的对象,调用方法的时候它会自动去找对应子类的方法,这就是对象的向上转型和向下转型

    向上转型

    父类对象通过子类对象去实例化,实际上就是对象的向上转型。向上转型是不需要进行强制类型转换的,但是向上转型会丢失精度。

    向下转型

    所谓向下转型,也就是说父类的对象可以转换为子类对象,但是需要注意的是,这时则必须要进行强制的类型转换。

    多态的好处

    1. 可替换性(substitutability)。多态对已存在代码具有可替换性。例如,多态对圆Circle类工作,对其他任何圆形几何体,如圆环,也同样工作。
    2. 可扩充性(extensibility)。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性,以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如,在实现了圆锥、半圆锥以及半球体的多态基础上,很容易增添球体类的多态性。
    3. 接口性(interface-ability)。多态是超类通过方法签名,向子类提供了一个共同接口,由子类来完善或者覆盖它而实现的。如图8.3 所示。图中超类Shape规定了两个实现多态的接口方法,computeArea()以及computeVolume()。子类,如Circle和Sphere为了实现多态,完善或者覆盖这两个接口方法。
    4. 灵活性(flexibility)。它在应用中体现了灵活多样的操作,提高了使用效率。
    5. 简化性(simplicity)。多态简化对应用软件的代码编写和修改过程,尤其在处理大量对象的运算和操作时,这个特点尤为突出和重要。

    子代父类实例化,然后就相当于一个父亲有很多儿子,送快递的给这个父亲的儿子送东西,他只需要送到父亲的家就行了,至于具体是那个儿子的,父亲还会分不清自己的儿子么,所以你就不用操心了。

    使用多态是一种好习惯

    多态方式声明是一种好的习惯。当我们创建的类,使用时,只用到它的超类或接口定义的方法时,我们可以将其索引声明为它的超类或接口类型。

    它的好处是,如果某天我们对这个接口方法的实现方式变了,对这个接口又有一个新的实现类,我们的程序也需要使用最新的实现方式,此时只要将对象实现修改一下,索引无需变化。

    比如Map< String,String> map = new HashMap < String,String>();想换成HashTable实现,可以Map< String,String> map = new HashTable < String,String>();

    比如写一个方法,参数要求传递List类型,你就可以用List list = new ArrayList()中的list传递,但是你写成ArrayList list = new ArrayList()是传递不进去的。尽管方法处理时都一样。另外,方法还可以根据你传递的不同list(ArrayList或者LinkList)进行不同处理。

    在Java编程思想这本书中有介绍

    展开全文
  • java 多态的好处

    2013-11-27 01:40:00
    /* 对象多态性。 class 动物{} class 猫 extends 动物{} class 狗 extends 动物{} ...猫这类事物即具备者猫形态,又具备着动物形态。这就是对象多态性。...多态在代码中体现:父类或者接口引用指向...

    /*

    对象的多态性。

    class 动物
    {}

    class 猫 extends 动物
    {}

    class 狗 extends 动物
    {}

     

    猫 x = new 猫();

    动物 x = new 猫();//一个对象,两种形态。

     

    猫这类事物即具备者猫的形态,又具备着动物的形态。
    这就是对象的多态性。

    简单说:就是一个对象对应着不同类型.

    多态在代码中的体现:
     父类或者接口的引用指向其子类的对象。


    多态的好处:
     提高了代码的扩展性,前期定义的代码可以使用后期的内容。

    多态的弊端:
     前期定义的内容不能使用(调用)后期子类的特有内容。

    多态的前提:
     1,必须有关系,继承,实现。
     2,要有覆盖。

     

    */

    abstract class Animal
    {
     abstract void eat();

    }

    class Dog extends Animal
    {
     void eat()
     {
      System.out.println("啃骨头");
     }
     void lookHome()
     {
      System.out.println("看家");
     }
    }

    class Cat extends Animal
    {
     void eat()
     {
      System.out.println("吃鱼");
     }
     void catchMouse()
     {
      System.out.println("抓老鼠");
     }
    }

    class Pig extends Animal
    {
     void eat()
     {
      System.out.println("饲料");
     }
     void gongDi()
     {
      System.out.println("拱地");
     }
    }

     

    class DuoTaiDemo
    {
     public static void main(String[] args)
     {
      
    //  Cat c = new Cat();
    //  c.eat();
    //  c.catchMouse();

      Animal a = new Cat(); //自动类型提升,猫对象提升了动物类型。但是特有功能无法s访问。
           //作用就是限制对特有功能的访问。
           //专业讲:向上转型。将子类型隐藏。就不用使用子类的特有方法。


    //  a.eat();

      //如果还想用具体动物猫的特有功能。
      //你可以将该对象进行向下转型。
    //  Cat c = (Cat)a;//向下转型的目的是为了使用子类中的特有方法。
    //  c.eat();
    //  c.catchMouse();

    //  注意:对于转型,自始自终都是子类对象在做着类型的变化。
    //  Animal a1 = new Dog();
    //  Cat c1 = (Cat)a1;//ClassCastException


      /*
      Cat c = new Cat();

    //  Dog d = new Dog();

    //  c.eat();
      method(c);
    //  method(d);
    //  method(new Pig());
      */

      method(new  Dog());

     }

     public static void method(Animal a)//Animal a = new Dog();
     {
      a.eat();

      if(a instanceof Cat)//instanceof:用于判断对象的具体类型。只能用于引用数据类型判断
    //      //通常在向下转型前用于健壮性的判断。

      {
       Cat c = (Cat)a;
       c.catchMouse();
      }
      else if(a instanceof Dog)
      {
       Dog d = (Dog)a;
       d.lookHome();
      }
      else
      {
      
      }
      
     }
     /*
     public static void method(Cat c)
     {
      c.eat();
     }
     public static void method(Dog d)
     { 
      
     }
     */ 
    }

    转载于:https://www.cnblogs.com/flying607/p/3444770.html

    展开全文
  • 多态的好处:A:提高了代码的维护性(继承保证)B:提高了代码的扩展性(由多态保证)猫狗案例代码1 classAnimal {2 public voideat(){3 System.out.println("eat");4 }56 public voidsleep(){7 System.out.println("sleep...

    多态的好处:

    A:提高了代码的维护性(继承保证)

    B:提高了代码的扩展性(由多态保证)

    猫狗案例代码

    1 classAnimal {2 public voideat(){3 System.out.println("eat");4 }5

    6 public voidsleep(){7 System.out.println("sleep");8 }9 }10

    11 class Dog extendsAnimal {12 public voideat(){13 System.out.println("狗吃肉");14 }15

    16 public voidsleep(){17 System.out.println("狗站着睡觉");18 }19 }20

    21 class Cat extendsAnimal {22 public voideat() {23 System.out.println("猫吃鱼");24 }25

    26 public voidsleep() {27 System.out.println("猫趴着睡觉");28 }29 }30

    31 class Pig extendsAnimal {32 public voideat() {33 System.out.println("猪吃白菜");34 }35

    36 public voidsleep() {37 System.out.println("猪侧着睡");38 }39 }40

    41 //针对动物操作的工具类

    42 classAnimalTool {43 privateAnimalTool(){}44

    45 /*

    46 //调用猫的功能47 public static void useCat(Cat c) {48 c.eat();49 c.sleep();50 }51

    52 //调用狗的功能53 public static void useDog(Dog d) {54 d.eat();55 d.sleep();56 }57

    58 //调用猪的功能59 public static void usePig(Pig p) {60 p.eat();61 p.sleep();62 }63 */

    64 public static voiduseAnimal(Animal a) {65 a.eat();66 a.sleep();67 }68 //把所有的可能都归为动物类

    69 }70

    71 classDuoTaiDemo2 {72 public static voidmain(String[] args) {73 //我喜欢猫,就养了一只

    74 Cat c = newCat();75 c.eat();76 c.sleep();77

    78 //我很喜欢猫,所以,又养了一只

    79 Cat c2 = newCat();80 c2.eat();81 c2.sleep();82

    83 //我特别喜欢猫,又养了一只

    84 Cat c3 = newCat();85 c3.eat();86 c3.sleep();87 //...

    88 System.out.println("--------------");89 //问题来了,我养了很多只猫,每次创建对象是可以接受的90 //但是呢?调用方法,你不觉得很相似吗?仅仅是对象名不一样。91 //我们准备用方法改进92 //调用方式改进版本93 //useCat(c);94 //useCat(c2);95 //useCat(c3);96

    97 //AnimalTool.useCat(c);98 //AnimalTool.useCat(c2);99 //AnimalTool.useCat(c3);

    100

    101 AnimalTool.useAnimal(c);102 AnimalTool.useAnimal(c2);103 AnimalTool.useAnimal(c3);104 System.out.println("--------------");105

    106 //我喜欢狗

    107 Dog d = newDog();108 Dog d2 = newDog();109 Dog d3 = newDog();110 //AnimalTool.useDog(d);111 //AnimalTool.useDog(d2);112 //AnimalTool.useDog(d3);

    113 AnimalTool.useAnimal(d);114 AnimalTool.useAnimal(d2);115 AnimalTool.useAnimal(d3);116 System.out.println("--------------");117

    118 //我喜欢宠物猪119 //定义一个猪类,它要继承自动物,提供两个方法,并且还得在工具类中添加该类方法调用

    120 Pig p = newPig();121 Pig p2 = newPig();122 Pig p3 = newPig();123 //AnimalTool.usePig(p);124 //AnimalTool.usePig(p2);125 //AnimalTool.usePig(p3);

    126 AnimalTool.useAnimal(p);127 AnimalTool.useAnimal(p2);128 AnimalTool.useAnimal(p3);129 System.out.println("--------------");130

    131 //我喜欢宠物狼,老虎,豹子...132 //定义对应的类,继承自动物,提供对应的方法重写,并在工具类添加方法调用133 //前面几个必须写,我是没有意见的134 //但是,工具类每次都改,麻烦不135 //我就想,你能不能不改了136 //太简单:把所有的动物都写上。问题是名字是什么呢?到底哪些需要被加入呢?137 //改用另一种解决方案。

    138

    139 }140

    141 /*

    142 //调用猫的功能143 public static void useCat(Cat c) {144 c.eat();145 c.sleep();146 }147

    148 //调用狗的功能149 public static void useDog(Dog d) {150 d.eat();151 d.sleep();152 }153 */

    154 }

    2、

    多态的弊端:

    不能使用子类的特有功能。

    我就想使用子类的特有功能?行不行?

    行。

    怎么用呢?

    A:创建子类对象调用方法即可。(可以,但是很多时候不合理。而且,太占内存了)

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

    对象间的转型问题:

    向上转型:

    Fu f = new Zi();

    向下转型:

    Zi z = (Zi)f; //要求该f必须是能够转换为Zi的.(所属关系)

    多态的问题理解:

    class 孔子爹 {

    public int age = 40;

    public void teach() {

    System.out.println("讲解JavaSE");

    }

    }

    class 孔子 extends 孔子爹 {

    public int age = 20;

    public void teach() {

    System.out.println("讲解论语");

    }

    public void playGame() {

    System.out.println("英雄联盟");

    }

    }

    //Java培训特别火,很多人来请孔子爹去讲课,这一天孔子爹被请走了

    //但是还有人来请,就剩孔子在家,价格还挺高。孔子一想,我是不是可以考虑去呢?

    //然后就穿上爹的衣服,带上爹的眼睛,粘上爹的胡子。就开始装爹

    //向上转型

    孔子爹 k爹 = new 孔子();

    //到人家那里去了

    System.out.println(k爹.age); //40

    k爹.teach(); //讲解论语

    //k爹.playGame(); //这是儿子才能做的

    //讲完了,下班回家了

    //脱下爹的装备,换上自己的装备

    //向下转型

    孔子 k = (孔子) k爹;

    System.out.println(k.age); //20

    k.teach(); //讲解论语

    k.playGame(); //英雄联盟

    2、向下转型中有可能的异常:

    ClassCastException:类型转换异常

    一般在多态的向下转型中容易出现

    展开全文
  • 之前对多态了解的不是特别清楚,现在权当是写个列子加深印象,说明适当的时候使用多态可以达到的好处。比如,现在在动物园,饲养员的话需要喂养很多动物,正常情况下的话,对饲养员来说需要一个一个去喂养,写成程序...
  • 请不要解释什么叫多态,多态的原理我已经很清楚了。只是暂时还没完全体会到它给我带来的好处,我现在就有个小疑问,比如说下面的程序:classComputer{publicvoidturnOn(){}}classPCex...请不要解释什么叫多态,多态...
  • 在学网络OSI模型时,我们知道了,因为人最适合思考问题复杂度为3-7,所以OSI才分了七层。而IT做多了,就知道了,随便一个简单系统其复杂度都成百上千,而IT三个世界,即从现实世界到计算机可运行数字世界要...
  • 多态的好处 A: 提高了代码的维护性(继承保证) B:提高了代码的扩展性(多态保证) */ /*猫狗的案例*/ class Animal{ public void eat(){ Systemout.println("eat"); } public void sleep(){ ...
  • 教妹学Java(三十六):Java 多态的好处

    千次阅读 2020-09-22 15:23:50
    多态有什么好处
  • 一、多态 –1、概念 同一对象,在不同时刻具有不同形态。 –2、特点 –前提: 发生继承关系 + 方法重写 –口诀1:父类引用指向子类对象 –Animal a = new Dog(); –口诀2:多态中,编译看左边,运行看右边 –编译...
  • 多态的好处:A:提高了代码的维护性(继承保证)B:提高了代码的扩展性(由多态保证)猫狗案例代码1 classAnimal {2 public voideat(){3 System.out.println("eat");4 }56 public voidsleep(){7 System.out.println("sleep...
  • 创建Test.java测试类代码说明:多态的好处并不仅仅是 父类引用指向子类对象(Animal animal = new Dog()),这样的话我们不能调用Dog子类中特用的方法和属性,我们在创建对象的时候直接创建子类对象更方便(Dog g = ...
  • 一,为了理解多态,我们先给出一个示例代码示例:(打印多种图形)class Shape{ 定义一个图形类作为父类public void draw(){//啥都不用干}}class Cycle extends Shape{@Override //声明重写父类中方法public void ...
  • 下面要给大家分享的是几个比较经典也很简单的java多态例题,感兴趣的小伙伴可以一起来...(1)、要有继承,还包括了接口的实现(2)、要有重写(3)、父类引用指向子类对象3、多态的好处是什么?主要有五大好处,分别是可替...
  • 多态的好处: 提高了代码的扩展性,前期定义的代码可以使用后期的内容。 多态的弊端: 前期定义的内容不能使用(调用)后期子类的特有内容。 多态的前提: 1.必须有关系,内容,实现。 2.要有覆盖。 ...
  • /*多态的好处:提高了代码的维护性和扩展性;弊端:父类不能使用子类的特有功能。要用子类的特有功能,可以:A:创建子类对象,调用方法即可(不合理,太占内存);B:把父类的引用强制转换为子类的引用(向下转型);...
  • Java-多态的好处

    2021-01-15 18:45:03
    讲师类,work(){ 讲课 } ...如果不用多态,只用子类,写法是: Teacher one = new Teacher(); one.work();//讲课 Assistant two = new Assisant(); two.work();//辅导 我现在唯一要做事情,就是调用wo...
  • Java多态的好处与弊端

    千次阅读 2019-04-23 22:03:07
    多态的好处 1.提高的代码的维护性(继承保证,即可以通过改写父类属性与方法同义改写子类共有属性与方法) 2.提高了代码的扩展性(由多态保证,即父类为形式参数,接收任意子类对象,在开发的时候用多态,扩展性强)...
  • 看了这个,我终于知道了...多态的好处: 1.提高了代码的可维护性 2.提高了代码的扩展性 多态的作用: 可以当做形式参数,可以接受任意子类对象 多态的弊端: 不能使用子类特有的属性和行为 案例演示: ...
  • 函数的多态性:函数重载、重写1、多态的体现父类的引用指向了自己的子类对象父类的引用也可以接收自己的对象2、多态的前提必须是类与类之间只有关系,要么继承或实现通常还有一个前提,存在覆盖3、多态的好处多态的...
  • Java多态形式_Java多态

    2021-03-10 09:49:26
    多态是同一个行为具有多个不同表现形式或者形态的能力。多态就是一个接口,使用不同的实例而执行不同操作,如图所示:多态存在的...多态的好处:可以使程序有良好的扩展,并可以对所有类的对象进行通用处理。package...
  • package java_learn; /* 多态多态成员访问特点: 1)成员变量:编译看左边,执行看左边; 2)成员方法:编译看左边,执行看右边。 为什么不一样?--因为成员方法有重写,而成员变量没有。 */ public class...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,174
精华内容 869
关键字:

java多态的好处

java 订阅