推荐

黑木爷Charlie

B

错

java多态有两种情况：重载和覆写

在覆写中，运用的是动态单分配，是根据new的类型确定对象，从而确定调用的方法；

在重载中，运用的是静态多分派，即根据静态类型确定对象，因此不是根据new的类型确定调用的方法

编辑于 2016-03-26 19:41:57 回复(43)

stevenniu

public class Father {
   public void say(){
       System.out.println("father");
   }
   public static void action(){
       System.out.println("爸爸打儿子！");
   }
}
public class Son extends Father{
    public void say() {
        System.out.println("son");

}

public static void action(){
System.out.println("打打！");
}

    public static void main(String[] args) {
        Father f=new Son();
        f.say();
        f.action();
    }

}

输出：son

爸爸打儿子！

当调用say方法执行的是Son的方法，也就是重写的say方法
而当调用action方法时，执行的是father的方法。

普通方法，运用的是动态单分配，是根据new的类型确定对象，从而确定调用的方法；

静态方法，运用的是静态多分派，即根据静态类型确定对象，因此不是根据new的类型确定调用的方法

发表于 2016-03-13 22:36:08 回复(51)

牛客470322号

引用毕向东教程的一段话：

1.成员变量：编译和运行都参考左边。

2.成员函数（非静态）：编译看左边，运行看右边

3.静态函数：编译和运行都看左边。

发表于 2016-08-16 08:52:41 回复(19)

牛客6975520号

一个类实现一个接口，new 一个接口，例如 public interface Dao{}这是一个接口， public class DaoImpl implements Dao{

实现接口中的方法}，Dao dao = new DaoImpl();

发表于 2017-09-06 09:37:36 回复(0)

Rico123

考察关于多态的理解。Java 多态主要体现在父子类之间，当然也包括类内多态（重载）。而父子类之间多态性往往是通过覆盖来体现的，而发生覆盖的对象是实例方法。换句话说，覆盖针对的是实例方法，调用的是当前对象引用运行时类型中定义的方法，属于运行期绑定；而对于成员变量和静态方法而言，根本不存在覆盖，而是隐藏。隐藏是指运行时系统调用当前对象引用编译时类型中定义的方法，属于编译期绑定。换句话说，引用是谁，就调用谁中的方法。

52798666”。欢迎留言，欢迎指教！

发表于 2016-12-05 15:34:35 回复(0)

讀書卟茹養潴

父类中有个haha方法，然后父类 fulei=new 子类（）；调用filei.haha(),不是子类的方法，所以不是new哪个就是调用哪个类…个人理解

发表于 2015-09-08 09:07:31 回复(2)

半纸流年

举个简单的例子，子类继承父类，但是没有实现其中的方法，当进行向上转型赋值时，调用的方法就只是父类的

发表于 2015-11-03 22:07:14 回复(21)

牛客719357号

多态==晚绑定或动态绑定
不要把函数重载理解为多态，因为多态是一种运行期行为，不是编译器行为。
多态：父类的引用指向子类的实例。
比如 Parent p = new Child()
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；
如果有，再去调用子类的同名方法。
静态方法特殊，静态方法只能继承，不能覆盖，如果子类有和父类相同的静态方法，只是起到隐藏父类方法的作用。这时候，谁的引用就调用谁的方法。

发表于 2016-04-27 10:37:26 回复(14)

hudawei

覆盖也是多态。

父类中有普通方法method

子类覆盖普通方法method

父类中有静态方法staticMethod

子类覆盖静态方法staticMethod

父类 father = new 子类();

此时

father.method会调用子类的method

father.staticMethod会调用父类的staticMethod

发表于 2016-03-30 14:53:57 回复(6)

xiaotiao

public class Father {

   public void say(){
       System.out.println("father");
   }

   public void action(){
       System.out.println("爸爸打儿子！");
   }
}
public class Son extends Father{

    @Override
    public void say() {
        //super.say();
        System.out.println("son");
    }

    public static void main(String[] args) {
        Father f=new Son();
        f.say();
        f.action();
    }
}

当调用say方法执行的是Son的方法，也就是重写的say方法
而当调用action方法时，执行的是father的方法。不知解释是否合理。

发表于 2015-09-23 11:39:22 回复(7)

joso

Java的多态调用中：
1、如果调用的是静态方法，因为静态方法没有重写，只有隐藏，因此根据引用的类型来调用。
2、如果调用的是非静态方法，则不管子类有没有重写方法，都是根据对象来调用。因为即使子类没有重写，调用的方法也是子类从父类继承得到的，也属于子类

编辑于 2017-06-05 20:38:40 回复(0)

TeddyTangBiSheng

//这里有个合适的例子，讲的是父类私有方法不能被覆盖。
public class A5DuoTai3
{
	
	private void m1()
	{
		System.out.println("父类私有方法调用");
	}
	
	public static void main(String[] args)
	{
		A5DuoTai3 a=new B();
		a.m1();
/*
    输出结果为"父类私有方法调用",
    并不是调用B中的m1方法“子类重写方法调用”
*/

	}
}

class B extends A5DuoTai3
{
	public void m1()
	{
		System.out.println("子类重写方法调用");
	}
}

编辑于 2015-10-16 20:58:24 回复(6)

kmust_XiaQing

B.

多态可以是在一个类中通过方法的重载也可以是多个类中方法的重写。此题只说了前一种情况

在多个类中，子类如果重写了父类的方法，那么new的如果是子类，就会调用子类的方法，例如：Animal a = new Cat(),那么a.eat()调用的方法是Cat类的eat()方法,而不是Animal的eat()方法

在同一个类中，通过方法的重载实现多态。

发表于 2015-08-28 11:31:39 回复(3)

183****7091

new的是哪一个类就是调用的哪个类的方法。

发表于 2014-11-21 17:30:34 回复(0)

Holiday_12138

发表于 2017-06-20 10:41:18 回复(1)

时间的沙漏

个人觉得这题描述有问题，光看后半句“new的是哪一个类就是调用的哪个类的方法 ”，这半句是半对半错的，那么可以选错。而关键是前半句“在java的多态调用中 ”，这半句的意思就有点含糊不清了，个人觉得前半句的语意指的是在子类继承父类覆盖了父类的某些方法，而程序调用了这些方法，这才称的上是多态调用。不然的话，子类没有覆盖父类方法，调用父类的方法，如何称得上是多态调用呢。

发表于 2017-03-15 15:12:04 回复(2)

Pck1in

只有非静态方法运行才看右边

引用毕向东教程的一段话：

1.成员变量：编译和运行都参考左边。

2.成员函数（非静态）：编译看左边，运行看右边

3.静态函数：编译和运行都看左边。

发表于 2022-03-11 11:12:21 回复(0)

大连球迷在此

多态存在的三个必要条件:

一、要有继承；

二、要有重写；

三、父类引用指向子类对象。

所以推荐的那个答案在说啥？这道题我觉得问题的描述就太简单了，不好，要是非要个解释的话应该是:

半纸流年-轻描了谁的夏天

举个简单的例子，子类继承父类，但是没有实现其中的方法，当进行向上转型赋值时，调用的方法就只是父类的

发表于 2019-03-18 11:32:47 回复(0)

趁年轻不如拼一拼

多态三个条件：

1、是否继承

2、是否重写

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

如果子类重写父类方法，多态形式，调用子类重写的方法。如果子类没有重写，则调用父类的方法。

发表于 2021-12-24 18:39:07 回复(0)

zzzzzqf

class Second extends Main{
    int a = 2;
    static int b = 2;
    public void f(){
        System.out.println("子类成员方法");
    }
    public static void g(){
        System.out.println("子类静态方法");
    }
}

public class Main {
    int a = 1;
    static int b = 1;

    public void f(){
        System.out.println("父类成员方法");
    }
    public static void g(){
        System.out.println("父类静态方法");
    }

    public static void main(String[] args) {
        Main m1 = new Main();
        m1.f();
        m1.g();
        System.out.println("成员变量和静态变量 "+m1.a+","+m1.b);
        System.out.println("-----");
        Main m2 = new Second();
        m2.f();
        m2.g();
        System.out.println("成员变量和静态变量 "+m2.a+","+m2.b);
        System.out.println("-----");
        Second s = new Second();
        s.f();
        s.g();
        System.out.println("成员变量和静态变量 "+s.a+","+s.b);
    }
}

输出：

父类成员方法
父类静态方法
成员变量和静态变量 1,1
-----
子类成员方法
父类静态方法
成员变量和静态变量 1,1
-----
子类成员方法
子类静态方法
成员变量和静态变量 2,2

编辑于 2020-05-25 18:51:34 回复(0)

大胖雪

构成多态的三大必要条件：

继承
覆写Override
父类的引用指向子类的对象

静态方法和属性其实没有多态的概念。

对于普通方法，如果满足上面三个必要条件，会采用就近原则，如果子类覆写了父类的方法，调用这个方法时，会采用子类的方法。即new了哪个类，就是用哪个类的方法。

对于静态方法或者是属性，由于不属于多态的范畴，也就是按照引用类型来调用。

题目中调用的方法如果是静态方法，就是错的。

发表于 2019-03-11 19:37:03 回复(0)

判断对错。在java的多态调用中，new的是哪一个类就是调用

关于 Java 继承、多态与类的复用的更详细的阐述，请查看我的博客“http://blog.csdn.net/justloveyou_/article/details/52798666”。欢迎留言，欢迎指教！

问题信息

热门推荐

相关试题

判断对错。在java的多态调用中，new的是哪一个类就是调用

关于 Java 继承、多态与类的复用 的更详细的阐述，请查看我的博客“http://blog.csdn.net/justloveyou_/article/details/52798666”。欢迎留言，欢迎指教！

问题信息

热门推荐

相关试题

关于 Java 继承、多态与类的复用的更详细的阐述，请查看我的博客“http://blog.csdn.net/justloveyou_/article/details/52798666”。欢迎留言，欢迎指教！