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

[jungwen]

如下程序的输出，为什么是: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);
}
}

[jessica0403]

方法肯定没有被重写阿.
你的参数类型就不一样.

方法重写必须满足:
(1) 子类的方法的名称及参数必须和所覆盖的方法相同

(2) 子类的方法返回类型必须和所覆盖的方法相同

(3) 子类方法不能缩小所覆盖方法的访问权限

(4) 子类方法不能抛出比所覆盖方法更多的异常

[t475242703]

申明的是父类 。实例化子类，会先调用父类的那个方法。

[lzu_vc]

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);

}
}

[lin49940]

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

[bluejoy345]

MyPerson mytemp = new subMyPerson();
mytemp 是一个上转型对象（就是这样定义的，具体的上转型对象解释自己翻书）

首先看下特点：
上转型对象不能操作子类新增的成员变量（失掉了这部分属性）；
不能使用子类新增的方法（失掉了一些功能）。
上转型对象可以操作子类继承或者隐藏的成员变量，也可以使用子类继承的或者重写的方法。
上转型对象操作子类继承或重写的方法，其作用等价于子类对象去调用这些方法。
因此，如果子类重写了父类的某个方法，则当对象的上转型对象调用这个方法时一定是调用了这个重写的方法

从21楼重写要满足的条件我们知道，这不是重写。
于是，子类的mydisplay(char abc)方法属于是子类新增加的方法，所以mytemp永远不可能执行子类的这个方法。所以，在父类没有mydisplay(char abc)这个方法的时候，Char类型自动转换为int型，执行父类的mydisplay(int abc)方法。如果把父类的方法改成mydisplay(String abc)，类型转换失败，程序就会出错，并不是跟楼上所说那样先执行父类后执行子类。

[zzhzcl15]

当子类实现父类的方法时。如果外部程序调用这个方法时，就会调用父类的方法，而不是子类实现的方法。

解决的办法是：
1、覆盖你类的方法。@override

[QLAN__]

刚学的

方法重载：
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);

}

}

[qianqiande123]

[Quote=引用 25 楼 bluejoy345 的回复:]
MyPerson mytemp = new subMyPerson();
mytemp 是一个上转型对象（就是这样定义的，具体的上转型对象解释自己翻书）

首先看下特点：
上转型对象不能操作子类新增的成员变量（失掉了这部分属性）；
不能使用子类新增的方法（失掉了一些功能）。
上转型对象可以操作子类继承或者隐藏的成员变量，也可以使用子类继承的或者重写的方法。
上转型对象操作子类继承或……
[/Quote]
这哥们实战百度的把，跟上面一模一样...不过很有道理....

[junyao100]

[Quote=引用 1 楼 dragonisgod 的回复:]
子类没有覆写父类的mydisplay(int abc)方法，参数类型不一样，业也就是子类对象指向父类对象，所以不能调用自身的mydisplay(char abc)，所以结果为MyPerson
[/Quote]

顶……晕死咯，差点吧方法的重载和继承之间的关系给搞混了 ……

[bluejoy345]

[Quote=引用 31 楼 qianqiande123 的回复:]
引用 25 楼 bluejoy345 的回复:
MyPerson mytemp = new subMyPerson();
mytemp 是一个上转型对象（就是这样定义的，具体的上转型对象解释自己翻书）

首先看下特点：
上转型对象不能操作子类新增的成员变量（失掉了这部分属性）；
不能使用子类新增的方法（失掉了一些功能）。
上转型对象可以操作子类继承或者隐藏的成员变量，也可以使用子类继……
[/Quote]

就上转型对象的特点是百度的，太多了，懒的打，自己也记不全

[我是辉子]

你的子父类中的mydisplay(int a) mydisplay(char a)
在子类中而言，只能算是函数的重载

重载和重写的定义是不一样的 先在书上看下概念吧

[zjh645461639]

既不是重写父类方法，也不是重载，如果说是重写方法的话它们参数不同，说是重载吧又不在同一个类中

[dddddz]

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

[清峰]

这个一定要懂。很多tx回答了，慢慢看吧，多敲代码就了解了

[jungwen]

学习了

[yangghost]

[Quote=引用 39 楼 zk278518173 的回复:]
就是因为形参不一样..不是重写~是新建了一个方法吧??是重载么谁说声啊
[/Quote]
不是重载.
请看6楼

[hljzhf]

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

[清峰]

好多高手回答了

[heartraid86]

《【解惑】Java动态绑定机制的内幕》

大伙看看，不知道有没有什么地方写的不妥的。在JVM运行过程中是如何准确定位到方法在内存中的位置的。

[zk278518173]

就是因为形参不一样..不是重写~是新建了一个方法吧??是重载么谁说声啊