小弟看到毕老师的视频，想问一下多态的扩展性是在什么情况下能用得到呢？

重写父类方法后，可以实现功能极大扩展，你可以试着调试一下下面的代码

1. public class ExtendsTest  {
   
2.         public static void main(String[] args) {
   
3.                 Person p1 = new Chinese();
   
4.                 Person p2 = new Japanese();
   
5.                 Person p3 = new American();
   
6.                 Person[] plist = new Person[]{p1,p2,p3};
   
7.                 for(int i=0;i<3;i++){
   
8.                         plist[i].sayHello();
   
9.                 }
   
10. 
    
11.         }
    
12. 
    
13. }
    
14. 
    
15. abstract class Person{
    
16.         abstract void sayHello();
    
17. }
    
18. 
    
19. class Chinese extends Person{
    
20. 
    
21.         @Override
    
22.         void sayHello() {
    
23.                 System.out.println("Hello,I am Chinese");
    
24.         }
    
25.        
    
26. }
    
27. class Japanese extends Person{
    
28. 
    
29.         @Override
    
30.         void sayHello() {
    
31.                 System.out.println("Hello,I am Japanese");
    
32.         }
    
33.        
    
34. }
    
35. class American extends Person{
    
36. 
    
37.         @Override
    
38.         void sayHello() {
    
39.                 System.out.println("Hello,I am American");
    
40.         }
    
41.        
    
42. }

复制代码

运行结果是：
Hello,I am Chinese
Hello,I am Japanese
Hello,I am American
重写父类方法后，可以实现功能极大扩展，由此可见一斑

多态有编译时多态 和运行时多态。第一个是通过方法重载实现；第二个是通过方法覆盖实现（子类覆盖父类方法）。第一种就是我们调用方法是不用区分参数类型，程序会自动执行相应方法，如： 加法运算，可以使int相加，可以是double相加，都是同一个方法名。第二种就是动态绑定，使用父类引用指向子类对象，再调用某一父类中的方法时，不同子类会表现出不同结果。 这样的作用就是扩展性极好，玩过网游的话应该知道 游戏中有不同的角色，它们都有一个父类，它们做相同动作时表现出来的效果就会不一样，比如跑，魔法师的跑跟战士的跑就不会一样，这就是俩者都覆盖了父类中的跑方法，各自有自己的现实，表现出来多态。  如果有一天你想再加个角色，只用再写一个类继承该父类，覆盖其中的跑方法就行了，其他代码不用怎么改，所以可维护性也很好。