毕老师关于多态有这么一句话：
多态的弊端：只能使用父类的引用访问父类中的成员，出现访问局限。


我的疑问是：这弊端如何理解?
多态为何会出现访问局限？

这问题问的没水平，毕题。

就是说在父类引用指向子类对象的时候，只能访问父类中有的方法或变量  比如Father  f = Son  s();  这时候父类的引用f就只能访问Father中有的变量，如果子类有覆盖父类的方法，那就调用子类的方法，如果没有就调用父类的方法；；；

这是不是跟 向上转型有关系？

class Fu
{
        void method1()
        {
                System.out.println("fu method1");
        }
        void method2()
        {
                System.out.println("fu method2");
        }
        static void method4()
        {
                System.out.println("fu method4");
        }
}
class Zi extends Fu
{
        void method1()
        {
                System.out.println("zi method1");
        }
        void method3()
        {
                System.out.println("zi method3");
        }
        static void method4()
        {
                System.out.println("zi method4");
        }
}

class DuoTaiDemo
{
        public static void main(String[] args)
        {
                Fu f=new Zi();
                f.method1();//对象所属类有调用方法，则执行对象中方法，运行时看右边               
                f.method2();//对象所属类没有调用方法，执行父类中方法，运行时看右边               
                //f.method3();  // 编译时不通过，因为父类中没有method3()，编译时看左边    也就是楼主所说父类引用不能访问子类函数         
                f.method4();//函数为静态函数时，执行父类函数，无论编译还是运行都看左边               
        }
}
结果：
zi method1
fu method2
fu method4

1. class Fu
   
2. {
   
3. String name="zhangsan";
   
4. void show()
   
5. {
   
6. System.out.println("Fu");
   
7. }
   
8. public static void method()
   
9. {
   
10. System.out.println("父类方法");
    
11. }
    
12. 
    
13. }
    
14. class Zi extends Fu
    
15. {
    
16. String name="lisi";
    
17. void show()
    
18. {
    
19. System.out.println("Zi");
    
20. 
    
21. }
    
22. public static void method()
    
23. {
    
24. System.out.println("子类方法");
    
25. }
    
26. 
    
27. }
    
28. public class Test1
    
29. {
    
30. public static void main(String[] args)
    
31. {
    
32. Fu f=new Zi();
    
33. f.show();
    
34. System.out.println(f.name);
    
35. f.method();
    
36. 
    
37. }
    
38. 
    
39. }

复制代码

楼上的回答很完善了，我就添加点代码吧
多态中成员函数的特点（非静态）：------>动态绑定

编译：参阅引用变量所属类是否有调用的方法，有则通过，没有则失败
f调用show方法，f属于类Fu，先检查Fu中是否有show方法，如果没有那么编译失败

执行：参阅对象所属类是否有调用的方法，有则调用对象类的方法，没有则调用引用变量所属类的方法
对象是new Zi()，属于类Zi，执行时先查看Zi是否有show方法，如果有就执行Zi的show方法，若没有，就执行Fu中的show方法

多态中成员变量及静态成员函数：-------->静态绑定

编译和执行的时候都是参阅引用变量所属类，即均参阅左边的类。
多态中的成员变量是不存在覆盖的，所以输出的还是引用变量f属于类Fu中的成员变量的值zhangsan
其中静态成员函数，不依附于对象存在，所以引用是哪个类就执行哪个类的方法。
静态成员函数也是绑定的，f.method()方法输出的是“父类方法”