class Animal{
    public String name;
    public int age;

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

    public void eat(){
        System.out.println(name +" 正在吃饭！（Animal）");
    }
}
class Dog extends Animal{

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
         System.out.println(name +" 正在吃狗粮");
    }
}
class Bird extends Animal{
    public String wing;
    public Bird(String name, int age) {
        super(name, age);
    }

   public void fly() {
        System.out.println(getName()+" 正在飞！");
    }

    @Override
    public void eat() {
        System.out.println(name +" 正在吃鸟粮");
    }
}

///分割线//
public class Main {
// 编译器在编译代码时，并不知道要调用Dog 还是 Cat 中eat的方法
// 等程序运行起来后，形参a引用的具体对象确定后，才知道调用那个方法
// 注意：此处的形参类型必须时父类类型才可以
    public static void eat(Animal a){
        a.eat();
    }
    public static void main(String[] args) {
        Bird bird = new Bird("鹦鹉",2);
        Dog dog = new Dog("狗子", 1);
        eat(bird);
        eat(dog);
    }
}

下面画图讲解一下，什么是多态。

在上述代码中, 分割线上方的代码是类的实现者编写的, 分割线下方的代码是类的调用者编写的.
当类的调用者在编写 eat 这个方法的时候, 参数类型为 Animal (父类), 此时在该方法内部并不知道，也不关注当前的a 引用指向的是哪个类型(哪个子类)的实例，此时 a这个引用调用 eat方法可能会有多种不同的表现(和 a 引用的实例相关),，这种行为就称为多态。

2.3 重写

2.3.1 重写的概念

重写(override)：也称为覆盖。
重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据对象的需要，定义特定于自己的行为。也就是说子类能够根据需要实现或者叫做改写父类的方法。
上述代码中的eat就是重写，调用两个对象的时候，都执行的是bird和dog中的eat方法，也就是对父类Animal中eat方法的重写。

2.3.2 重写规则

子类在重写父类的方法时，一般必须与父类方法原型一致：修饰符返回值类型方法名(参数列表) 要完全一致；
被重写的方法返回值类型可以不同，但是必须是具有父子继承关系的；
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为 protected；
父类被static、private修饰的方法、构造方法都不能被重写。
重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验，例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写。

2.3.3 重写和重载的区别

区别	重载	重写
参数列表	必须修改	不能修改
返回类型	可以修改	不能修改
访问限定符	可以修改	子类要大于父类的访问修饰符等级