关于java的多态

Question

class AA{
public void pr(Object o){
System.out.println("A-Object");
}
}
public class BB extends AA {
public void pr(Object o){
System.out.println("B-Object");
}
public void pr(String a){
System.out.println("B-string");
}
public static void main(String[] args) {
String str = "1";
AA c = new BB();
c.pr(str);
}
}
上面代码的运行结果是B-Object,
我感觉结果应该是B-String啊

Answer 1

public void pr(String a){ 
System.out.println("B-string"); 
} 好像是不可达代码。Object o会吧String a覆盖，String a方法不会显示

Answer 2

你这里是使用父类去创建的一个子类对象，所以该对象只能具有父类的属性和方法，和父类匹配的方法只能是参数为object的方法。

Answer 3

你这里是使用父类去创建的一个子类对象，所以该对象只能具有父类的属性和方法，和父类匹配的方法只能是参数为object的方法。

Answer 4

动态绑定，因为指向的是bb的对象，所以c.pr（）  就是bb里重写的父类的pr方法。不要被这个public void pr(String a)方法弄晕了， 这里和它没关系

Answer 5

public void pr(String a){ 
System.out.println("B-string"); 
} 
并不造成Override，而是Overload,相当于一个新的方法。Eclipse里面都没有Override三角号提示。

Answer 6

你调用的是c.pr(str); 
c的类型是父类的，调用c的pr方法但是因子类重写了父类的pr方法，因此调用子类的pr(Object)方法
因父类找不到pr(String ..)方法。此因这里str发生了多态，把str转换成了Object。
但是如果你在父类里边添加个pr(String...)的方法，就会直接调用String的参数的方法。

Answer 7

class AA {
public void pr(Object o) {
System.out.println("A-Object");
}
}public class BB extends AA {
public void pr(Object o) {
System.out.println("B-Object");
} public void pr(String a) {
System.out.println("B-string");
} public static void main(String[] args) {
String str = "1";
AA c = new BB();//因为是AA类型的引用,所以只能调用BB类中从AA类中继承下来方法,实现动态绑定.BB类自己再定义的方法AA调用不了的.
c.pr(str);
}
}

Answer 8

小菜回答：  重写：子类重写父类的方法。要求同名同参同返回 所以 public class BB extends AA { 
public void pr(Object o){ 
System.out.println("B-Object"); 
} 
public void pr(String a){ 
System.out.println("B-string"); 
} 
这个类中 只有 public void pr(Object o){ 
System.out.println("B-Object"); 
} 这个方法是重写父类的方法。 而public void pr(String a){ 
System.out.println("B-string"); 
} 是方法的重载。 所以当定义一个父类的应用指向子类对象时 当调用父类的方法（被子类重写过） 就掉用子类重写父类的那个方法而在子类中只有
public void pr(Object o){ 
System.out.println("B-Object"); 
} 这个方法是重写父类的方法。

Answer 9

因为是AA类型的引用,所以只能调用BB类中从AA类中继承下来方法,实现动态绑定.BB类自己再定义的方法AA调用不了的.

Answer 10

public class BB {
    public static void pr(Object a){
     System.out.println("Object --A");
    }
    
    public static void pr(String a){
     System.out.println("String --A");
    }
    
    public static void main(String[] args){
     Object obj = new Object();
     pr(obj);
     String str = new String();
     pr(str);
    }
}
result:Object --A
String --A所以一楼说法好象有点说不过去

Answer 11

你写的代码跟继承没有关系啊。你的代码跟继承，多态一点关系都没有。-_-!楼主代码正确答案应该是：1.父类创建子对象c，这里c调用的函数方法将会子类BB的方法，重写public void pr(Object o){}2.虽然申请一个字符串，但是这里我认为还是会屏蔽public void pr(String a){ } 方法的。如果你继续这样定义：AA c = new BB();  大家试试看看能不能输出B-string。

Answer 12

11楼的观点有些是错的.
首先C是一个引用,不能说是一个对象,
第二,c是AA类的引用,只能调用AA类中定义过的方法,public void pr(String a)在AA类中没有,调用不了的,这样理解才是正确

Answer 13

class AA{
public void pr(Object o){
System.out.println("A-Object");
}
//public void pr(String o){
//System.out.println("A-String");
//}
}
public class BB extends AA {public void pr(Object o){
System.out.println("B-Object");
}
public void pr(String a){
System.out.println("B-string");
}public static void main(String[] args) {
String str = "1";
AA c = new BB();
c.pr(str);
}
} 因为AA的引用c是由子类BB的对象创建的，产生多态：
1因为你的方法是pr(String),所以首先调用子类从父类继承的方法pr(String),现在没有
2那么又是多态可以与子类BB从父类ＡＡ继承的pr(Object)匹配，输出你的结果，假如现在没有父类ＡＡ没有pr(Object)
3那么就调用子类自己的pr(String)方法,若子类没有，
4那么就与子类中方法参数是String父类的方法匹配，pr(Object)即可。很不幸，若还没有
 那么就报错了。所以多态的顺序大概是1，2， 3，4

Answer 14

汗。。我又打错了。。1.父类创建子对象new BB（）和父类的引用c，形成多态，这里c调用的方法是子类BB重写的public void pr(Object o){} 2.虽然申请一个字符串，但是这里我认为还是会屏蔽public void pr(String a){ } 方法的。//意思是说通过这样定义AA c = new BB();将会永远也调用不了public void pr(String a){ } 方法的。

Answer 15

能实现多态的机制只能是方法重写，public void pr(String a)这是方法重载，无法形成多态

Answer 16

class AA{
public void pr(Object o){
System.out.println("A-Object");
}
}
public class BB extends AA {
public void pr(Object o){
System.out.println("B-Object");//这个叫重写
}
public void pr(String a){//这个叫重载
System.out.println("B-string");
}
public static void main(String[] args) {
String str = "1";
AA c = new BB();//你创建了一个BB对象，用类型AA应用他
c.pr(str);//这个时候要多态了
}
} 因为AA只会查找他所写过的方法类型，如果实际对象已经重写过了，就会调用实际对象的方法。
在调用实际对象的时候又进行了类型转换，ok

Answer 17

这个不是多态问题。把子类的String 换成Object 叫做重写吧!多态是在同个类中吧？
呵呵，我也是小菜...

Answer 18

AA没有pr(String str){}这个方法！BB的pr(String str)并没有覆盖AA其中的方法，所以不能多态调用BB的pc(String str)方法，
父类对象变量引用的子类的对象，所以调用子类的pr(Object object)方法

Answer 19

AA c = new BB();//你创建了一个BB对象，用类型AA应用他
c.pr(str);//这个时候要多态了
//不得不介绍一下动态联编，就是在运行的时候才能确定要调用的是那个方法
//在上边的调用中运行的时候，jvm会选择实际类型BB的方法pr（object ob）这也就是所谓的多态

Answer 20

这里不存在方法重载的意思！子类BB的pr(Object object)覆盖父类pr(Object object)方法

Answer 21

public class BB extends AA {
public void pr(Object o){
System.out.println("B-Object");
}
public void pr(String a){//这两个方法不是重载吗，虽然pr(String a)并没有被用到
System.out.println("B-string");
}

Answer 22

我好笨啊，都看不懂PS: 
我的目标是 ----> ^_^

Answer 23

类多态:
1.父子类之间,即:有继承发生
2.子类重写了父类的方法
3.父类的引用指向子类对象
    满足上边的三个条件,在调用父类中的被重写的时候,调用的实际上是子类中重写后的方法
    1楼楼主的问题中 main()方法调用的是父类中的public void pr(Object o)方法,即,调用的实际是子类中的
public void pr(Object o)方法 ,跟另一个方法就没关系.

Answer 24

如果第2步通不过,编译器在检查阶段就直接报错了,不会到编译那一步,c是AA类的引用,虽然是new了一个BB,但是就像是使用强制转换
BB bb = new BB();
c = (AA)bb;
一样,最后得到的c是bb中去掉AA中不存在的方法的AA对象,所以只能使用AA中定义的所有方法.
bb.pr("");//调用BB的public void pr(String a)
bb.pr(new Object())//调用BB的public void pr(Object o)