精华内容
下载资源
问答
  • 多态的好处

    2015-10-15 09:22:56
    多态的好处(扩展性强) */ //动物类 class dong{  public void sleep(){  System.out.println("睡觉");  }  public void eat(){  System.out.println("吃饭");  } } //猫类 class mao extends ...

    /*
    多态代码体现
    多态的好处(扩展性强)
    */
    //动物类
    class dong{
     public void sleep(){
      System.out.println("睡觉");
     }
     public void eat(){
      System.out.println("吃饭");
     }
    }
    //猫类
    class mao extends dong{
     public void sleep(){
      super.sleep();
      System.out.println("猫趴着");
     }
     public void eat(){
      super.eat();
      System.out.println("猫吃鱼");
     }
    }
    //狗类
    class dog extends dong{
     public void sleep(){
      super.sleep();
      System.out.println("狗躺着");
     }
     public void eat(){
      super.eat();
      System.out.println("狗吃骨头");
     }
    }
    //猪类
    class pig extends dong{
     public void sleep(){
      super.sleep();
      System.out.println("猪站着");
     }
     public void eat(){
      super.eat();
      System.out.println("猪拱白菜");
     }
    }
    //  工具类
    class ju{
     public void Fe(dong d){
      d.sleep();
      d.eat();
     }
    }
    //测试类
    class dogDemo1{
     public static void main(String[] args){
      /*
      mao m=new mao();
      m.sleep();
      m.eat();
      dog d=new dog();
      d.sleep();
      d.eat();
      pig p=new pig();
      p.sleep();
      p.eat();
      System.out.println("------------");//创建对象,一个一个调用方法 
      */
      dong m=new mao();
      dong d=new dog();
      dong p=new pig();
      /*
      dong m1=new mao();
      dong m2=new mao();
      dong d1=new dog();
      dong d2=new dog();
      dong p1=new pig();
      dong p2=new pig();
      j.Fe(m1);
      j.Fe(d1);
      j.Fe(p1);
      j.Fe(m2);
      j.Fe(d2);
      j.Fe(p2);
      */
      ju j=new ju();
      j.Fe(m);
      j.Fe(d);
      j.Fe(p);//创建工具类,使用多态,工具类调用

     }
    }

    展开全文
  • /*对象的多态性。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)

    {

    }

    */

    }

    展开全文
  • 多态的好处: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:类型转换异常

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

    展开全文
  • 多态的好处和弊端以及多态的理解

    千次阅读 2018-01-31 18:51:03
    java8-3 多态的好处和弊端以及多态的理解 多态的好处: A:提高了代码的维护性(继承保证) B:提高了代码的扩展性(由多态保证) 猫狗案例代码 class Animal { public void eat(){ System.out.println("eat...
    转载自:
    

    java8-3 多态的好处和弊端以及多态的理解

    多态的好处:
    A:提高了代码的维护性(继承保证)
    B:提高了代码的扩展性(由多态保证)

    猫狗案例代码
    class Animal {
        public void eat(){
            System.out.println("eat");
        }
        
        public void sleep(){
            System.out.println("sleep");
        }
    }
    
    class Dog extends Animal {
        public void eat(){
            System.out.println("狗吃肉");
        }
        
        public void sleep(){
            System.out.println("狗站着睡觉");
        }
    }
    
    class Cat extends Animal {
        public void eat() {
            System.out.println("猫吃鱼");
        }
        
        public void sleep() {
            System.out.println("猫趴着睡觉");
        }
    }
    
    class Pig extends Animal {
        public void eat() {
            System.out.println("猪吃白菜");
        }
        
        public void sleep() {
            System.out.println("猪侧着睡");
        }
    }
    
    //针对动物操作的工具类
    class AnimalTool {
        private AnimalTool(){}
    
        /*
        //调用猫的功能
        public static void useCat(Cat c) {
            c.eat();
            c.sleep();
        }
        
        //调用狗的功能
        public static void useDog(Dog d) {
            d.eat();
            d.sleep();
        }
        
        //调用猪的功能
        public static void usePig(Pig p) {
            p.eat();
            p.sleep();
        }
        */
        public static void useAnimal(Animal a) {
            a.eat();
            a.sleep();
        }
        //把所有的可能都归为动物类
    }
    
    class DuoTaiDemo2 {
        public static void main(String[] args) {
            //我喜欢猫,就养了一只
            Cat c = new Cat();
            c.eat();
            c.sleep();
            
            //我很喜欢猫,所以,又养了一只
            Cat c2 = new Cat();
            c2.eat();
            c2.sleep();
            
            //我特别喜欢猫,又养了一只
            Cat c3 = new Cat();
            c3.eat();
            c3.sleep();
            //...
            System.out.println("--------------");
            //问题来了,我养了很多只猫,每次创建对象是可以接受的
            //但是呢?调用方法,你不觉得很相似吗?仅仅是对象名不一样。
            //我们准备用方法改进
            //调用方式改进版本
            //useCat(c);
            //useCat(c2);
            //useCat(c3);
            
            //AnimalTool.useCat(c);
            //AnimalTool.useCat(c2);
            //AnimalTool.useCat(c3);
            
            AnimalTool.useAnimal(c);
            AnimalTool.useAnimal(c2);
            AnimalTool.useAnimal(c3);
            System.out.println("--------------");
            
            //我喜欢狗
            Dog d = new Dog();
            Dog d2 = new Dog();
            Dog d3 = new Dog();
            //AnimalTool.useDog(d);
            //AnimalTool.useDog(d2);
            //AnimalTool.useDog(d3);
            AnimalTool.useAnimal(d);
            AnimalTool.useAnimal(d2);
            AnimalTool.useAnimal(d3);
            System.out.println("--------------");
            
            //我喜欢宠物猪
            //定义一个猪类,它要继承自动物,提供两个方法,并且还得在工具类中添加该类方法调用
            Pig p = new Pig();
            Pig p2 = new Pig();
            Pig p3 = new Pig();
            //AnimalTool.usePig(p);
            //AnimalTool.usePig(p2);
            //AnimalTool.usePig(p3);
            AnimalTool.useAnimal(p);
            AnimalTool.useAnimal(p2);
            AnimalTool.useAnimal(p3);
            System.out.println("--------------");
            
            //我喜欢宠物狼,老虎,豹子...
            //定义对应的类,继承自动物,提供对应的方法重写,并在工具类添加方法调用
            //前面几个必须写,我是没有意见的
            //但是,工具类每次都改,麻烦不
            //我就想,你能不能不改了
            //太简单:把所有的动物都写上。问题是名字是什么呢?到底哪些需要被加入呢?
            //改用另一种解决方案。
            
        }
        
        /*
        //调用猫的功能
        public static void useCat(Cat c) {
            c.eat();
            c.sleep();
        }
        
        //调用狗的功能
        public static void useDog(Dog d) {
            d.eat();
            d.sleep();
        }
        */
    }

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

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

    怎么用呢?
    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:类型转换异常
    一般在多态的向下转型中容易出现



    展开全文
  • 多态的好处和弊端

    千次阅读 2018-07-14 21:50:32
    多态的好处和弊端 A:多态的好处 a:提高了代码的维护性(继承保证) b:提高了代码的扩展性(由多态保证) B:案例演示 多态的好处 可以当作形式参数,可以接收任意子类对象 C:多态的弊端 不能使用子类的特有属性...
  • 之前对多态了解的不是特别清楚,现在权当是写个列子加深印象,说明适当的时候使用多态可以达到的好处。比如,现在在动物园,饲养员的话需要喂养很多动物,正常情况下的话,对饲养员来说需要一个一个去喂养,写成程序...
  • 请不要解释什么叫多态,多态的原理我已经很清楚了。只是暂时还没完全体会到它给我带来的好处,我现在就有个小疑问,比如说下面的程序:classComputer{publicvoidturnOn(){}}classPCex...请不要解释什么叫多态,多态...
  • 多态的好处作用

    2019-04-06 21:56:00
    多态的好处:提高了代码的扩展性,前期定义的代码可以使用后期的内容,就是后期有父类或接口 被子类继承,实现后那么 只要方法参数类型是父类的,都可以使用-------------定义一个父类:Animal package Polymorphic...
  • 看了这个,我终于知道了...多态的好处: 1.提高了代码的可维护性 2.提高了代码的扩展性 多态的作用: 可以当做形式参数,可以接受任意子类对象 多态的弊端: 不能使用子类特有的属性和行为 案例演示: ...
  • 多态的好处:A:提高了代码的维护性(继承保证)B:提高了代码的扩展性(由多态保证)猫狗案例代码1 classAnimal {2 public voideat(){3 System.out.println("eat");4 }56 public voidsleep(){7 System.out.println("sleep...
  • 多态的好处: A:提高了代码的维护性(继承保证) B:提高了代码的扩展性(由多态保证) 猫狗案例代码 1 class Animal { 2 public void eat(){ 3 System.out.println("eat"); 4 } 5 6 public void ...
  • 继承是多态的前提,为什么我们在学习或者工作中会使用多态呢? 首先,我们要了解在多态中的两个规则: 1.成员变量:编译看=的左边,运行还是看左边 ...下面这个图可以很直观的看出多态的好处: ...
  • 多态的好处和弊端: 1.多态的好处:提高了程序的扩展性 具体:定义方法的时候,使用父类型作为参数,将来在使用的时候,使用具体的子类型参与操作 2.弊端:不能使用子类的特有功能 /** * @author Wrry * @...
  • 多态的好处与弊端

    2017-08-23 14:43:53
    2.6多态的好处与弊端 当父类的引用指向子类对象时,就发生了向上转型,即把子类类型对象转成了父类类型。向上转型的好处是隐藏了子类类型,提高了代码的扩展性。 但向上转型也有弊端,只能使用父类共性的内容,而...
  • Java面向对象 多态的好处

    千次阅读 2019-04-19 13:18:48
    多态的好处,建议参考一个百度回答: https://zhidao.baidu.com/question/217864684.html?hideOtherAnswer=true&newAnswer=1 例如一段代码: class Computer { public void turnOn() { } } class PC ...
  • 一、多态 –1、概念 同一对象,在不同时刻具有不同形态。 –2、特点 –前提: 发生继承关系 + 方法重写 –口诀1:父类引用指向子类对象 –Animal a = new Dog(); –口诀2:多态中,编译看左边,运行看右边 –编译...
  • 1.多态的好处: 如果不用多态,只用子类,那么写法是: Teacher one = new Teacher(); one.work(); //讲课 Assistant two = new Assistant(); tow.work(); //辅导 我作为老板,现在唯一要做的事情是:...
  • Java中多态的好处与弊端

    千次阅读 2019-04-23 22:03:07
    多态的好处 1.提高的代码的维护性(继承保证,即可以通过改写父类属性与方法同义改写子类共有属性与方法) 2.提高了代码的扩展性(由多态保证,即父类为形式参数,接收任意子类对象,在开发的时候用多态,扩展性强)...
  • 多态的好处和弊端以及对象的向上转型和向下转型 多态的好处 提高了代码的可维护性(继承保证) 2.提高了代码的扩展性(由多态保证) // An highlighted block var foo = 'bar';
  • 多态、多态的好处(扩展性)

    万次阅读 多人点赞 2018-08-14 09:41:51
    2、多态的前提:1)要有继承关系;2)要有方法重写;3)要有父类引用指向子类`Fu f= new Zi(); 例如,动物 d= new 狗( ),形参实参形式的(形参父类实参子类)。 多态中成员访问特点 Fu f= new Zi();//左父类右...

空空如也

空空如也

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

多态的好处