精华内容
下载资源
问答
  • 请不要解释什么叫多态,多态的原理我已经很清楚了。只是暂时还没完全体会到它给我带来的好处,我现在就有个小疑问,比如说下面的程序:classComputer{publicvoidturnOn(){}}classPCex...请不要解释什么叫多态,多态...

    请不要解释什么叫多态,多态的原理我已经很清楚了。只是暂时还没完全体会到它给我带来的好处,我现在就有个小疑问,比如说下面的程序:classComputer{publicvoidturnOn(){}}classPCex...

    请不要解释什么叫多态,多态的原理我已经很清楚了。只是暂时还没完全体会到它给我带来的好处,我现在就有个小疑问,比如说下面的程序:

    class Computer{

    public void turnOn(){

    }

    }

    class PC extends Computer{

    public void turnOn(){

    System.out.println("PC has turn on");

    }

    }

    class NB extends Computer{

    public void turnOn(){

    System.out.println("NB has turn on");

    }

    }

    class Test{

    public void go(Computer computer){

    computer.turnOn();

    }

    }

    go(new PC());

    go(new NB());

    ————————————————————

    对于上面的程序,我这样写不也挺好吗:

    PC pc = new PC();

    NB nb = new NB();

    pc.turnOn();

    nb.turnOn();

    为什么非要费那事重新写个go方法再调用它呢

    强调一遍不要再解释多态的概念

    对xianlaioy

    虽然不知道会不会有新电脑,那万一新写了一个类A又继承了Computer,也实现了turnOn方法,如果我想调用A中的turnOn方法,不还得new一个A么,既然有了A对象的引用不还是可以直接a.turnOn()么

    对he036002

    其实我不是想怀疑它,只是这根筋一下子没扭过来

    对odouaa ——

    是不是项目大才能体现出来?

    你说的程序中我这样不也行吗,直接调用student.say()让它直接告诉我,因为这样也可以不用管它是什么类型,因为我只要知道它继承了Person类就肯定实现了say()方法。这样岂不是更方便,还省得在School里面定义一个foundPerson()方法。

    我不是故意这样问,我也知道多态是面向对象的核心,只是一下子想法没扭过来

    展开

    展开全文
  • Java中多态的好处与弊端

    千次阅读 2019-04-23 22:03:07
    多态的好处 1.提高的代码的维护性(继承保证,即可以通过改写父类属性与方法同义改写子类共有属性与方法) 2.提高了代码的扩展性(由多态保证,即父类为形式参数,接收任意子类对象,在开发的时候用多态,扩展性强)...

    多态的好处

    1.提高的代码的维护性(继承保证,即可以通过改写父类属性与方法同义改写子类共有属性与方法)
    2.提高了代码的扩展性(由多态保证,即父类为形式参数,接收任意子类对象,在开发的时候用多态,扩展性强)

    代码示例:

    public class Test {
    	public static void main(String [] args) {
    		method(new Cat());
    		method(new Dog());
    	}
    	/*
    	public static void method(Animal a) {		//父类为形式参数,接收任意子类对象
    		a.eat();
    	}
    	*/
    	public static void method(Animal a) {	
    		//关键字 instanceof 判断前边的引用是否是后边的数据类型 
    		if (a instanceof Cat) {
    			Cat c = (Cat)a;
    			c.eat();
    			c.catchMouse();
    		}else if (a instanceof Dog) {
    			Dog d = (Dog)a;
    			d.eat();
    			d.lookHome();
    		}else {
    			a.eat();
    		}
    			
    		}
    	
    }
    
    class Animal {
    	
    	public void eat() {
    		System.out.println("动物吃饭");
    	}
    }
    
    class Cat extends Animal {
    	
    	public void eat() {
    		System.out.println("猫吃鱼");
    	}
    	
    	public void catchMouse() {
    		System.out.println("猫捉老鼠");
    	}
    	
    }
    
    class Dog extends Animal {
    	public void eat() {
    		System.out.println("狗吃屎");
    	}
    	
    	public void lookHome() {
    		System.out.println("狗看家");
    	}
    	
    }
    
    展开全文
  • /*对象的多态性。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)

    {

    }

    */

    }

    展开全文
  • 看了这个,我终于知道了...多态的好处: 1.提高了代码的可维护性 2.提高了代码的扩展性 多态的作用: 可以当做形式参数,可以接受任意子类对象 多态的弊端: 不能使用子类特有的属性和行为 案例演示: ...

    看了这个,我终于知道了为什么要用多态了

    看了大量的资料和视频之后,我终于搞清了多态的作用了,废话不多说,直接上干货!

    多态的好处:

              1.提高了代码的可维护性

              2.提高了代码的扩展性

    多态的作用:

               可以当做形式参数,可以接受任意子类对象

    多态的弊端:

                不能使用子类特有的属性和行为

    案例演示:

       父类与子类:

    class Animal{

              public void eat(){

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

                  }

    }

    class Cat extends Animal{

               public void eat(){

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

                 }

                public void CatchMouse(){

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

                }

    }

    class Dog extends Animal{

               public void eat(){

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

                 }

    }

    主类:

    //加入现在需要创建三个猫对象和三个狗对象并使用eat方法,如果我们按照正常的思路:

    class Demo_Animal{

           public static void main(String[] args) {

            Cat c1=new Cat();

            Cat c2=new Cat();

            Cat c3=new Cat();

            Dog d1=new Dog();

            Dog d2=new Dog();

            Dog d3=new Dog();

            c1.eat();

            c2.eat();

            c3.eat();

            d1.eat();

            d2.eat();

            d3.eat();

              }

    }

    //显然这样写代码冗余,我们可以先优化一下创建对象和调用方法的过程,把创建对象和调用方法的过程提取成为一个方法

    class Demo_Animal{

           public static void main(String[] args) {

              method(Cat c1);

              method(Cat c2);

              method(Cat c3);

              method(Dog d1);

              method(Dog d2);

              method(Dog d3);

                  }

         public static void method(Cat c){

           c.eat();

                  }

         public static void method(Dog d){

           d.eat();

                  }

    }

    //这个时候,如果有十个,百个类,猫,狗,猪,牛,羊........我们每次都需要写一个对应的method,这样是不现实的,因

    //此我们需要进一步优化,使用多态,把父类当做形参

    class Demo_Animal{

           public static void main(String[] args) {

           method(Cat c1);  

           method(Cat c2);  

           method(Cat c3);  

           method(Dog d1);  

           method(Dog d2);  

           method(Dog d3);  

           }

           public static void method(Animal a){

            a.eat(); 

            }

    从这个案例中我们可以明显的感受到多态的优点,我所使用的父类作为形参的方法也是在工作时最为常用的一种方式,以上是我花了大功夫总结的多态,希望对看到的你有所帮助! 

    展开全文
  • package java_learn; /* 多态多态成员访问特点: 1)成员变量:编译看左边,执行看左边; 2)成员方法:编译看左边,执行看右边。 为什么不一样?--因为成员方法有重写,而成员变量没有。 */ public class...
  • Java中多态的好处: 提高了代码的维护性(继承保证) 提高了代码的扩展性 猫狗案例举例: //定义一个动物类 class Animal { public void eat() { System.out.println("eat"); } public void sleep()...
  • 一,为了理解多态,我们先给出一个示例代码示例:(打印多种图形)class Shape{ 定义一个图形类作为父类public void draw(){//啥都不用干}}class Cycle extends Shape{@Override //声明重写父类中的方法public void ...
  • 一,为了理解多态,我们先给出一个示例 代码示例:(打印多种图形) class Shape{ 定义一个图形类作为父类 public void draw(){ ... @Override //声明重写父类中的方法 public void draw(){ S...
  • –口诀2:多态中,编译看左边,运行看右边 –编译看左边:想要保存成功,使用父类提供功能 –运行看右边:想要结果,找子类 –3、入门案例 package com.xsd.multi; //这类用来 测试 多态 public class Test2_...
  • Java中多态

    2019-09-20 20:02:38
    Java中的多态 1.多态的表现 编译时类型与运行时类型不一致 例如:School stu=new Student(); 等号左边是编译时类型,右边是运行时类型 2.前提:(1)子类继承父类 (2)子类重写父类的方法 ...3.多态的好处...
  • 好处】提高了程序扩展性【弊端】通过父类引用操作子类对象时,只能使用父类已有方法,不能操作子类特有方法。【前提】1,必须有关系:继承、实现、2,通常都有重写操作。多态技术引出解决了程序扩展性...
  • java 多态的好处

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

    2019-01-15 23:30:35
    java中多态的理解 在处理类型的层次结构时,经常想把一个对象不当作它所属的特定类型来对待,而是当做其基类的对象来对待,这就使得程序员不得不编写依赖于特定对象的代码, 几何形例子: 方法操作的都是泛化的形状,不用...
  • 而IT做多了,就知道了,随便一个简单系统其复杂度都成百上千,而IT三个世界,即从现实世界到计算机可运行数字世界要靠我们IT人头脑中的想象世界作为桥梁进行翻译。那我们该如何管理其间复杂度呢?!通过OSI...
  • java中多态的概念

    2019-09-30 04:57:06
    概念: 简答来说,多态(Polymorphism)是具有表现多种形态的能力的特征。 更专业的说法是:同一个实现接口,... 继承是多态的基础,没有继承就没有多态。 转载于:https://www.cnblogs.com/mycifeng/p/5274863.h...
  • Java的多态

    2020-10-24 18:08:17
    Java的多态 一、什么是多态? 一种引用类型,多种表现形式。在满足一定的条件下,子类可以转换成父类,用父类的对象即可调出公有的方法,且方法的形式是子类定义的。 二、多态的条件 ...三、多态的好处
  • 知识点:多态的概念、java中多态的使用(方法重载和重写、子类对象的多态性) 、多态使用的好处一:什么是多态一种事物的多种存在形态,比如说男人和女人都是人,人可以分为男人和女人二:java中多态的使用场景(1)方法...
  • 面向对象的三大特征:1、封装;2、继承;3、多态。 多态的概念: 指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。 ...相同的快捷键在不同软件有...多态的好处 1
  • Java 的多态

    2021-03-02 09:27:42
    这里写自定义目录标题 Java多态 同一个行为具有多个形态或表现的能力 在Java中,多态就是同一个接口,使用不同的实例而...多态的好处 1.消除类型之间的耦合关系 2.可替换性 3.可扩充性 4.接口性 5.灵活性 6.简化性 ...
  • java的多态

    2020-03-01 12:49:29
    目录 多态的概述: 使用多态的 好处: 对象的向上/向下转型: 如何才能知道一个父类引用的对象,本来是什么子类?...使用多态的好处: 对象的向上/向下转型: 如何才能知道一个父类引用的对象,...

空空如也

空空如也

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

java中多态的好处

java 订阅