一个关于JAVA继承和重载的问题

Question

如下程序的输出，为什么是:MyPerson?!
class MyPerson {
public void mydisplay(int abc)
{
System.out.println("MyPerson");
}
}class subMyPerson extends MyPerson{
public void mydisplay(char abc)
{
System.out.println("SubMyPerson");
}
}public class MyTestProject {
public static void main(String[] args) {
char i1 = 100;
MyPerson mytemp = new subMyPerson();
mytemp.mydisplay(i1);
}
}

Answer 1

子类没有覆写父类的mydisplay(int abc)方法，参数类型不一样，业也就是子类对象指向父类对象，所以不能调用自身的mydisplay(char abc)，所以结果为MyPerson

Answer 2

MyPerson mytemp   你这里申明的是MyPerson    new subMyPerson(); 这里的subMyPerson类里的mydisplay对mytemp   事不可见的

Answer 3

 我觉得你把重载和重写两个混淆了重载是在同一个类中，方法名字相同，参数类型或个数不同重写是在有继承关系的两个类中，子类中把父类的一个方法重新写过，访问权限，返回类型，方法名，以及参数都与父类中的方法一致你所写的方法参数类型不一致，又在两个不同的类中，既不构成重载也不构成重写，完全不同的两个方法。。理解万岁不要以为传个char 的参数就调用子类的那个方法，char类型在没有重载的情况下可以自动的转换的int型的

Answer 4

class MyPerson 
{
public void mydisplay(int abc)
{
System.out.println("MyPerson");
}
}
//子类
class subMyPerson extends MyPerson
{
public void mydisplay(char abc)
{
System.out.println("SubMyPerson");
} 
}
public class MyTestProject 
{
public static void main(String[] args) 
{
char i1 = 100;
/**
 * @author 不再悲伤
 * 首先我得强调类中的函数是被重写过的；然后
 * 该subMyPerson类开辟一块内存给mytemp，然后
 * 被强制转化成Myperson类型。这样会导致原类会丢失
 * 一些东西，比如函数，此时启用原函数
 */
MyPerson mytemp = new subMyPerson();
mytemp.mydisplay(i1);
}
}
//输出结果：MyPerson

Answer 5

 子类继承父类，这个类先实例化父类，在实例化子类，
结果应当为：MyPerson
          SubMyPerson       

Answer 6

关键是子类实际上并没有覆盖父类的方法，这是两个不一样的方法同时，编译器在编译的过程中发现mytemp.mydisplay(i1);这个语句时，只能找到父类中对应的(int abc)这个方法可以匹配，所以编译器最后会要求调用int abc这个方法

Answer 7

父类引用指向子类对象 子类没有重写mydisplay方法(参数不一样)。
并且因为是父类引用 所以子类特有的方法对于对象是不可见的 故无法调用subMyPerson的方法

Answer 8

class MyPerson {

public void mydisplay(int abc)
{
System.out.println("MyPerson");
}
}class subMyPerson extends MyPerson{

public void mydisplay(char abc)
{
System.out.println("SubMyPerson");
} 
}public class MyTestProject {

public static void main(String[] args) {

char i1=100;
MyPerson mytemp = new subMyPerson();//可以这么理解 MyPerson mytemp确定申明的是MyPerson ,使用subMyPerson对象进行赋值，即覆盖！由于在MyPerson申明中没有mydisplay(char abc)的申明因此无法覆盖,只能作为重载。若把mydisplay(char abc)改成mydisplay(int abc)此时MyPerson中有mydisplay(int abc 的申明)因此可以覆盖。这就是覆盖和重载的区别！ mytemp.mydisplay(i1);

}
}

Answer 9

既不是覆盖, 更不是重载.
MyPerson 只知道有 mydisplay(int abc) 这个方法. 
你叫它怎么执行 mydisplay(char abc)方法呢?

Answer 10

MyPerson mytemp = new subMyPerson();
mytemp 是一个上转型对象（就是这样定义的，具体的上转型对象解释自己翻书）首先看下特点：
上转型对象不能操作子类新增的成员变量（失掉了这部分属性）；
不能使用子类新增的方法（失掉了一些功能）。 
上转型对象可以操作子类继承或者隐藏的成员变量，也可以使用子类继承的或者重写的方法。
上转型对象操作子类继承或重写的方法，其作用等价于子类对象去调用这些方法。
因此，如果子类重写了父类的某个方法，则当对象的上转型对象调用这个方法时一定是调用了这个重写的方法从21楼重写要满足的条件我们知道，这不是重写。
于是，子类的mydisplay(char abc)方法属于是子类新增加的方法，所以mytemp永远不可能执行子类的这个方法。所以，在父类没有mydisplay(char abc)这个方法的时候，Char类型自动转换为int型，执行父类的mydisplay(int abc)方法。如果把父类的方法改成mydisplay(String abc)，类型转换失败，程序就会出错，并不是跟楼上所说那样先执行父类后执行子类。

Answer 11

LS已经解释的很清楚很清楚了。补充一点，如果在MyPerson类中同时存在上面两个方法，即：class MyPerson {
  public void mydisplay(int abc)
  {
    System.out.println("MyPerson");
  }  public void mydisplay(char abc)
  {
    System.out.println("Char in MyPerson");
  }
}那么jvm会根据输入参数的精度调用最合适的方法。如下：char i1 = 65535;
Fa s = new Son();
s.mydisplay(i1); //invokevirtual MyPerson.mydisplay:(C)V
int i2 = 2;
s.mydisplay(i2); //invokevirtual MyPerson.mydisplay:(I)V

Answer 12

都越说越乱了哈。 一：没覆写父类方法，二：说重载的话，你传的参数“100”也是int型的啊，它不可能去调用char型的方法吧。

Answer 13

   当子类实现父类的方法时。如果外部程序调用这个方法时，就会调用父类的方法，而不是子类实现的方法。解决的办法是：
   1、覆盖你类的方法。@override

Answer 14

刚学的 方法重载：
1.应用在一个类的内部;
2.方法的名称相同，参数个数，类型不同比如：public class Book {
String press;
String bookName;
public Book()
{
System.out.println("无参数！");
}
public Book(String press)
{
System.out.println("本书出版社的名称是：："+press);
}
public Book(String bookName,String press)
{
this.bookName=bookName;
this.press=press;
System.out.println("本书的名称是：："+bookName);
System.out.println("本书出版社名称是："+press);
}
public static void main(String args[])
{
Book book1= new Book();
Book book2=new Book("任命出版社");
Book book3= new Book("JAVA","人民出版社");
}
}
方法重写：
1.应用在父,子类继承关系中;
2.方法重写不仅要求子类与父类的方法同名，而且方法的参数类型、个数以及方法的返回值类型都要与父类一致。
比如：
//定义父类Animal
public class Animal {
private String name;
public Animal(String name)
{
this.name=name;
}
//定义printInfo方法，用于输出animal的名称
public void printInfo(Animal animal)
{
System.out.println("My name is:"+animal.getName());
}
private String getName()
{
return name;
}
public void setName(String name)
{
this.name=name;
}
}
//定义子类Cat继承Animal
public class Cat extends Animal {
private String name;
public Cat(String name)
{
super(name);
this.name=name;
}
//Cat中的printInfo方法重写了父类Animal中的printInfo方法
public void printInfo(Cat cat)
{
System.out.println("My name is:"+cat.getName());
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
 //定义子类Dog继承Animal      
public class Dog extends Animal
{

private String name;
public Dog(String name)
{
                super(name);
this.name=name;
}
//Dog中的printInfo方法重写了父类Animal中的printInfo方法
public void printInfo(Dog dog)
{
System.out.println("My name is:"+dog.getName());
}
        public String getName() 
{
return name;
}
public void setName(String name) 
        {
this.name = name;
}
}
//测试类Test
public class Test {
public static void mian(String args[])
{
Animal animal1 = new Cat("小花");
Animal animal2 = new Dog("阿明");
animal1.printInfo(animal1);
animal2.printInfo(animal2);

}}

Answer 15

你的子父类中的mydisplay(int a) mydisplay(char a)
在子类中而言，只能算是函数的重载  重载和重写的定义是不一样的  先在书上看下概念吧

Answer 16

MyPerson mytemp = new subMyPerson();这里虽然定义了一个subMyPerson对象，但它的引用却是MyPerson 。而子类的方法和属性对于父类来说是不可见的。所以mytemp访问不到子类subMyPerson的方法，它调用的是它本身的方法。

Answer 17

class MyPerson {
public void mydisplay(int abc)
{
System.out.println("MyPerson");
}
}class subMyPerson extends MyPerson{
public void mydisplay(int abc)
{
System.out.println("SubMyPerson");
}
}public class MyTestProject {
public static void main(String[] args) {
char i1 = 100;
MyPerson mytemp = new subMyPerson();
mytemp.mydisplay(i1);
}
}输出
SubMyPerson输出完成 (耗时 0 秒) - 正常终止-----------------------------------------------------------------------------
class MyPerson {
public void mydisplay(int abc)
{
System.out.println("MyPerson");
}
}class subMyPerson extends MyPerson{
public void mydisplay(int abc)
{
System.out.println("SubMyPerson");
}
}public class MyTestProject {
public static void main(String[] args) {
char i1 = 100;
subMyPerson mytemp = new subMyPerson();
mytemp.mydisplay(i1);
}
}输出SubMyPerson

Answer 18

《【解惑】Java动态绑定机制的内幕》大伙看看，不知道有没有什么地方写的不妥的。在JVM运行过程中是如何准确定位到方法在内存中的位置的。