abstract class Animal
{
       abstract void eat();
}
class Cat extends Animal
{
       public void eat()//覆盖父类的方法
    {
              System.out.println("吃鱼");
       }
}
class Dog extends Animal
{
       public void eat()//覆盖父类的方法
    {
              System.out.println("吃骨头");
       }
}

class Demo
{
       public static void main(String[] args)
       {
              function(new Cat());//父类引用接受子类对象
        function(new Dog());//父类引用接受子类对象
    }
      public static void function(Animal a)//父类引用指向子类对象
    {
             a.eat();
       }
}

关于上面多态的问题，主函数创建一个function（）功能，通过父类引用指向子类对象，假如把Animal类的抽象eat（）注释掉，
编译失败，也就是说多态的时候调用父类方法，但是子类继承了父类，不是应该调用子类的方法吗？求解？

对象的上转型对象的实体是子类负责创建的，但是上转型对象会丢失原子类对象的一些属性和功能，上转型对象不能操作子类新增的方法。你把Animal类的抽象eat（）注释掉，子类中的eat（）就相当于新加的方法，因此编译失败

对象的上转型对象的实体是子类负责创建的，但是上转型对象会丢失原子类对象的一些属性和功能，上转型对象不能操作子类新增的方法。你把Animal类的抽象eat（）注释掉，子类中的eat（）就相当于新加的方法，因此编译失败

这个应该蛮好理解的吧，记住老毕的那句话，多态情况下，非静态编译看左边，运行时看右边。。。

你可以这么理解：
java源代码在执行时先编译，再运行。
编译的时候检查语法错误，你现在把父类的eat方法注释掉了，
编译器在检查错误的时候发现父类没有这个方法，于是报错。

父类引用指向子类对象，是多态的一种形式，就是将子类对象的堆内存地址，赋给父类引用类型的变量。
这种形式称为向上转型。向上转型是自动的。
还有另一种形式，子类引用指向父类的对象， 就是想父类对象的堆内存地址，赋给子类引用类型的变量

。这种形式称为向下转型。向下转型要进行强制转换。
多态有个非常重要的特点：就是在程序编译的时候使用是引用变量的特征，程序在运行的时候，使用的是

实际对象的特征。
实例：
//定义一个类，将这个类作为Son的父类。
class Father{
       //
       int age;
       //定义父类中的方法
       public void eat(){
        System.out.println("父类的方法被调用");
}
}

//定义一个类，将该类做为Father的子类
class Son extend Father{
        int age;
      //复写父类中的方法
        public void eat(){
        System.out.println("子类的方法被调用");
}
}
//编写测试类

public class Test{
       public static void main(String[] args){
        //使用向上转型；
       Father fa = new Son();
        //通过fa应用变量调用eat()方法
        fa.eat();//程序在编译时使用的是引用变量fa的特征，绑定的是Father中的eat()方法。
//到了程序运行的时变成了使用对象Son的特性，绑定的是Son中的eat()方法。
//所以程序运行的结果是"子类的方法被调用"。
//总结：多态的前提，要有继承关系，子类中复写父类的方法。这样才会有多态。
}
}