1. abstract class Animal{
   
2.       abstract void eat();
   
3. }
   
4. class Cat extends Animal{
   
5.       void eat(){
   
6.       s.o.p("fish")
   
7.       }
   
8.       void catchMouse(){
   
9.        s.o.p("do catch")
   
10.        }
    
11. }<div class="blockcode"><blockquote>
    

复制代码

class Demo{
      public static void main(String[] args){
        Animal a = new cat();
        //当需要调用到猫中的特有功能捉老鼠时，需要向下转型，
         Cat c = (Cat)a;
         c.catchMouse

Student s = new BaseStudent();
//此处运行结果是“坐着睡”，在调用到basestudent的特有功能sleep的时候，为什么没有进行转型，反而能够得到的却是子类的特有功能呢？
s.sleep;
       }
}

1. abstract class Student{
   
2. public abstract void study();
   
3. public void sleep(){
   
4. s.o.p("躺着睡")；
   
5. }
   
6. }
   
7. class BaseStudent extends Student{
   
8.       public void study(){
   
9.       s.o.p("base study");
   
10.       }
    
11.        public void sleep(){
    
12.        s.o.p("坐着睡")；
    
13.        }
    
14. }
    
15. 
    

复制代码

不明的地方在代码中红字的标示。

因为sleep()这个成员函数不是静态方法，
所以：在编译时，参考引用类型变量所属类中是否具有调用的函数，有，运行，没有，编译失败。
      在运行时，参考的是对象所属类中是否具有调用的函数，往父类里找，运行父类的。
你的代码中，因为子类和父类中都有sleep（）方法，所以编译通过，最后运行的就是实例对象中的sleep()方法，结果：“坐着睡”

你自己已经定义好了的，猫抓老鼠是猫的特殊方法，动物没有，当然要强转才能调用猫的方法，不然动物里没有抓老鼠的方法。基础班学生和学生这两个类中都定义了睡觉方法，基础班的学生继承并覆写了学生类的睡觉方法，自然直接调用基础班的学生睡觉方法不用强转。

你要看的就是，左边的类中有没有描述你要调用的内容，如果没有而子类有的话，就需要强转。如果父类和子类都有你想要调用的内容，那么最终调用的会是子类的内容，父类的内容被覆写。多态主要看的还是你使用的引用变量的类型是什么类型。引用变量的类型要看变量左边的类来决定的。

Student s = new BaseStudent();
s.sleep();
这是java的一个机制，多态是对于成员函数而言的，
对于非静态函数，
编译时，检查左边的类有没有被调用的方法；
运行时，由于子类对父类方法进行了覆盖，所以会调用子类的方法，这就是动态绑定。
对于静态函数，都属于静态绑定，因为静态是类的。
成员变量都是静态绑定。