java关于子类重写父类方法的疑问

[-Beginner-]

突然想起：为什么需要重写父类中的方法，如果子类需要方法，重新写一个方法不就行了。
求各位赐教！

class Human
{
	protected String name;
	protected int age;
	
	public Human()
	{
	}
	
	public Human(String name, int age)
	{
		this.name = name;
		this.age = age;
	}
	
	public String getInfo()
	{
		return "Name:"+this.name+"\n"+"Age:"+this.age;
	}
}
class Student extends Human
{
	int banji;
	String school;
	int score;
	
	public Student()
	{
	}

	public Student(String name, int age, String school, int banji, int score)
	{
		super(name, age);
		this.school = school;
		this.banji = banji;
		this.score = score;
	}
	
	public String getInfo()//这里的方法重新写一个不行吗？
	{
		return super.getInfo()+"\n"+"School:"+this.school+"\n"+"Class:"+this.banji+"\n"+"Score:"+this.score;
	}
}
public class Test_Student {
	public static void main(String[] args)
	{
		Student s = new Student("Ryahsa", 23, "Sichuan University of Art ant and Science", 3, 90);
		System.out.print(s.getInfo());
	}
}

[爱coding的卖油翁]

这是java的多态机制、用于简易开发的，多用就能体会到好处。楼上的例子就是详解。

[前进牦牛]

这是用于后面的多态做前提

[小小强0124]

为什么需要重写父类中的方法，如果子类需要方法，重新写一个方法不就行了。 其实吧，这就叫多态。重写父类的方法其实就是重新写了一个方法，只是方法名一样而已

[Gansuper7012]

引用 4 楼 u013432137 的回复:

为什么需要重写父类中的方法，如果子类需要方法，重新写一个方法不就行了。 其实吧，这就叫多态。重写父类的方法其实就是重新写了一个方法，只是方法名一样而已

你这么说貌似不合理吧。

[sleeplacker]

这是Java的多态性要求的，用到多态性的时候必须重写，因为只有重写了才能实现动态绑定，请看以下例子

class Cycle {
	public String type() {
		return "";
	}
}

class Unicycle extends Cycle {
	public String type() {
		return "Unicycle";
	}
}

class Bicycle extends Cycle {
	public String type() {
		return "Bicycle";
	}

}

class Tricycle extends Cycle {
	public String type() {
		return "Tricycle";
	}
}

public class Upcasting {
	public static void ride(Cycle c) {
		System.out.println("ride " + c.type());
	}

	public static void main(String[] args) {
		Unicycle uc = new Unicycle();
		Bicycle bc = new Bicycle();
		Tricycle tc = new Tricycle();
		ride(uc);
		ride(bc);
		ride(tc);
	}
}

如果你不重写type方法而是重新写一个新的方法(把方法名改为type1,type2,type3)，那么就实现不了上面程序的多态性，请看以下代码

class Cycle {
	public String type() {
		return "null";
	}
}

class Unicycle extends Cycle {
	public String type1() {
		return "Unicycle";
	}
}

class Bicycle extends Cycle {
	public String type2() {
		return "Bicycle";
	}

}

class Tricycle extends Cycle {
	public String type3() {
		return "Tricycle";
	}
}

public class Upcasting {
	public static void ride(Cycle c) {
		System.out.println("ride " + c.type());
	}

	public static void main(String[] args) {
		Unicycle uc = new Unicycle();
		Bicycle bc = new Bicycle();
		Tricycle tc = new Tricycle();
		ride(uc);
		ride(bc);
		ride(tc);
	}
}

[-Beginner-]

引用 1 楼 lg1544650023 的回复:

这是Java的多态性要求的，用到多态性的时候必须重写，因为只有重写了才能实现动态绑定，请看以下例子

class Cycle {
	public String type() {
		return "";
	}
}

class Unicycle extends Cycle {
	public String type() {
		return "Unicycle";
	}
}

class Bicycle extends Cycle {
	public String type() {
		return "Bicycle";
	}

}

class Tricycle extends Cycle {
	public String type() {
		return "Tricycle";
	}
}

public class Upcasting {
	public static void ride(Cycle c) {
		System.out.println("ride " + c.type());
	}

	public static void main(String[] args) {
		Unicycle uc = new Unicycle();
		Bicycle bc = new Bicycle();
		Tricycle tc = new Tricycle();
		ride(uc);
		ride(bc);
		ride(tc);
	}
}

如果你不重写type方法而是重新写一个新的方法(把方法名改为type1,type2,type3)，那么就实现不了上面程序的多态性，请看以下代码

class Cycle {
	public String type() {
		return "null";
	}
}

class Unicycle extends Cycle {
	public String type1() {
		return "Unicycle";
	}
}

class Bicycle extends Cycle {
	public String type2() {
		return "Bicycle";
	}

}

class Tricycle extends Cycle {
	public String type3() {
		return "Tricycle";
	}
}

public class Upcasting {
	public static void ride(Cycle c) {
		System.out.println("ride " + c.type());
	}

	public static void main(String[] args) {
		Unicycle uc = new Unicycle();
		Bicycle bc = new Bicycle();
		Tricycle tc = new Tricycle();
		ride(uc);
		ride(bc);
		ride(tc);
	}
}

好的 谢谢了 ！我还没看到多态去。 学到老，活到老！

[lliiqiang]

因为一个父类可以有多个子类，你无法知道当前是哪个子类，只能通过父类调用该方法.

[grapepaul]

根据您的疑惑，我觉得您可以理解overwrite是java提供的一个特性。 新function 和overwrite都可以解决您说的问题，overwrite还可以解决其他问题，后面再慢慢了解。

[风铃浩]

除了楼上几位说的之外,补充一点:虽然之类重写了父类的的方法,但不代表父类的方法就不会使用了.有可能父类的方法只是暂时的需要被改写.除了该子类是特殊情况以外,父类的方法仍需要继续被使用.java的多态让我们可以继续使用这两个方法.而且方法同名说明它们大致的功能很相似,可读性更高

[咖啡不放糖]

多态吧：继承，重写，父类引用指向子类对象

[二萌无双]

主要是用作多态。。。LZ看一下教材里面关于多态的介绍。。。面向对象的精髓。。。设计模式的基础。。

[lrenmin]

学习了,谢谢

[低调Di程序猿]

关键是实现动态绑定啊。。。。。这也是一个高级特性呢。。。

[wangzhangtv]

多态的调取，最主要是写接口这块，一些方法体的构造基本一致，不如写一个共通的接口来进行调去。 也为后面的代码维护提供了便利。