Java面向对象 多态的好处

多态的好处，建议参考一个百度回答：

https://zhidao.baidu.com/question/217864684.html?hideOtherAnswer=true&newAnswer=1

例如一段代码：

class Computer {
	public void turnOn() {
	}
}

class PC extends Computer {
	public void turnOn() {
		System.out.println("PC has turn on");
	}
}

class NB extends Computer {
	public void turnOn() {
		System.out.println("NB has turn on");
	}
}

class Test {
	public void go(Computer computer) {
		computer.turnOn();
		go(new PC());
		go(new NB());
	}
}

此时就会有小伙伴有疑问，

对于上面的程序，我这样写不也挺好吗：

PC pc = new PC();

NB nb = new NB();

pc.turnOn();

nb.turnOn();

为什么非要费那事重新写个go方法再调用它呢

虽然不知道会不会有新电脑，那万一新写了一个类A又继承了Computer，也实现了turnOn方法，如果我想调用A中的turnOn方法，不还得new一个A么，既然有了A对象的引用不还是可以直接a.turnOn()么

 

对此疑问有前辈已经用代码去进行了回答。

在实际操作中，多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法，而这些方法通过一个抽象类或者接口来实现，多态就是提供父类调用子类代码的一个手段而已。下面给一个例子

abstract class Person {
	private String name;
	private int age;

	Person(String name, int age) {
		this.name = name;
		this.age = age;
	}

	abstract void say();
}

class Student extends Person {
	Student(String name, int age) {
		super(name, age);
	}

	public void say() {
		System.out.println("I'am a Student");
	}
}

class Teacher extends Person {
	private String profession;

	Teacher(String name, int age, String profession) {
		super(name, age);
		this.profession = profession;
	}

	public void say() {
		System.out.println("I'am a Teacher");
	}
}

class School {
	private String schoolname;
	private Person person;

	School(String schoolname, Person person) {
		this.schoolname = schoolname;
		this.person = person;
	}

	public void foundPerson() {
		person.say();
	}
}

public class TestPolymoph {
	public static void main(String[] args) {
		Student studnet = new Student("lisi", 21);
		Teacher teacher = new Teacher("dudu", 29, "maths");
		School school1 = new School("changning", studnet);
		School school2 = new School("changning", teacher);
		school1.foundPerson();// I'am a Student
		school2.foundPerson();// I'am a Teacher
	}
}

School方法传递了抽象类Person，具体调用时是根据具体的实际实例化的对象调用对应的方法
强调一下：多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法，这就是多态的好处。
希望你能明白。呵呵。

 

对于以上的代码我觉得在TestPolymoph做一些改变会显得更加清晰

public class TestPolymoph {
	public static void main(String[] args) {
//		Student studnet = new Student("lisi", 21);
//		Teacher teacher = new Teacher("dudu", 29, "maths");
//		School school1 = new School("changning", studnet);
//		School school2 = new School("changning", teacher);
		
		School school1 = new School("changning", new Student("lisi", 21));
		School school2 = new School("changning",  new Teacher("dudu", 29, "maths"));
		
		school1.foundPerson();// I'am a Student
		school2.foundPerson();// I'am a Teacher
	}
}

用匿名内部类来体现多态将更加清晰，用户根本无需知道你所用的对象具体是什么类型的，你只需要用抽象父类以及其公共接口去引用该对象，能完成其功能就够了。 例如Collection集合中的 迭代器就是一个很好的例子。   

例如：

List list = new ArrayList();

list.Iteritor();

其直接返回一个iterator接口的直接实现，用户根本不知道 也无需知道返回的到底是什么类型的对象，因为Collection下不同的集合返回的迭代器实现类 并不相同。此时也就需要用到了接口多态。