多态的存在有三个前提:

1.要有继承关系
2.子类要重写父类的方法
3.父类引用指向子类对象

看下面几个例子，你就全明白了

第一个例子，仅有一个speak()方法

public class test {
    public static void main(String[] args) {
        father people = new son();
        people.speak();
    }
}
class father{
    public void speak() {
        System.out.println("i am father !");
    }
}
class son extends father{
    public void speak(){
        System.out.println("i am son !");
    }   
}

输出：

i am son !

第二个例子，多了一个age

public class test {
    public static void main(String[] args) {
        father people = new son();
        people.speak();
        System.out.println("i am "+people.getAge());
    }
}

class father{
    private int age ;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void speak() {
        System.out.println("i am father !");
    }
}
class son extends father{
     public son() {
        setAge(17);
    }
    public void speak(){
        System.out.println("i am son !");
    }
}

输出：

i am son !
i am 17

第三个例子，son中加了个play()

public class test {
    public static void main(String[] args) {
        father people = new son();
        people.speak();
        System.out.println("i am "+people.getAge());
        people.play();
    }
}

class father{
    private int age ;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void speak() {
        System.out.println("i am father !");
    }
}
class son extends father{
     public son() {
        setAge(17);
    }
    public void speak(){
        System.out.println("i am son !");
    }
    public void play(){
        System.out.println("i am son , i want to play!");
    }
}

输出：

<b>Exception in thread "main" java.lang.Error: Unresolved compilation problem:
The method play() is undefined for the type father
at com.data.model.test.main(test.java:11)</b>

很明显，father中缺少play()方法，所以不能执行。

第四个例子，animal

这里要介绍一个绑定的概念

1、将一个方法调用同一个方法主体关联起来 称作 绑定

• 如果在程序执行前进行绑定，叫做前期绑定（由编译器和连接程序实现）

• 而另外一种在程序执行时绑定的，叫做动态绑定，也叫后期绑定，运行时绑定
• 动态绑定也就是说编译器一直不知道对象的类型，但是可以根据方法调用机制找到正确的方法体

2、那么java中有哪些方法是属于动态绑定的呢？

• 除了static 、final方法之外（private方法也属于final方法），其他所有的方法都是后期绑定

• 也就是说 static 、final 方法都不具有多态性！
• 在编译时，编译器不需要获得任何特殊信息就能进行正确的调用

3、为什么要将某个方法声明为final 呢?

• 为了要防止重写，可以有效的关闭动态绑定
  4、多态的优点
• 可以忽略继承的类的变化，依旧可以正常运行，将改变的事物与围边的事物分离开来

class Animal{
    public void speak(){
        System.out.println("i am animal. i am speaking");
    }
    public void run(){
        System.out.println("i am animal , i am running");
        
    }
}

class Cat extends Animal{
    public void speak(){
        System.out.println("miao miao miao ~~");
    }
}

public class Polymorphic {
    /**
     * 这样就不用给每个animal编写方法了
     * 只要用这样的一个方法，就可以调用继承这个animal的类的所有重写的方法
     */
    public static void testAnimal(Animal animal){
        animal.speak();
    }
    
    public static void main(String[] args) {
        Cat cat = new Cat();
        testAnimal(cat);
    }
}

我们可以适当修改程序

    public static void main(String[] args) {
        Animal cat = new Cat();// 将Cat改成Animal
        testAnimal(cat);
    }

再深入，当我们建立一个新的类WhiteCat 继承Cat 时，也能够正确的调用

class WhiteCat extends Cat{
    public void speak(){
        System.out.println("miao~ miao~");
    }
}
public class Polymorphic {
    public static void testAnimal(Animal animal){
        animal.speak();
    }
    public static void main(String[] args) {
        Animal whiteCat = new WhiteCat();
        testAnimal(whiteCat);

    }
}

缺陷：域和静态方法

1、静态方法不具有多态性。

静态方法是与类相关联的

class Animal{
    public static void eat(){
        System.out.println("animal eat");
    }
}
class Cat extends Animal{
    public static void eat(){
        System.out.println("cat eat");
    }
}       
public class Polymorphic {
    public static void main(String[] args) {
        Animal cat = new Cat();
        cat.eat();
    }
}

输出：

animal eat

2、下面的举例是域的缺陷

• 当我们在每个class中都定义不同的age时

class Animal{
    public int age = 1;
    public void speak(){
        System.out.println("i am animal. i am speaking");
    }
    public void run(){
        System.out.println("i am animal , i am running");   
    }
}

class Cat extends Animal{
    public int age = 2;
    public void speak(){
        System.out.println("miao miao miao ~~");
    }
}

class WhiteCat extends Cat{
    public int age = 3;
    public void speak(){
        System.out.println("miao~ miao~");
    }
}

public class Polymorphic {
    /**
     * 这样就不用给每个animal编写方法了
     * 只要用这样的一个方法，就可以调用继承这个animal的类的所有重写的方法
     */
    public static void testAnimal(Animal animal){
        animal.speak();
    }
    
    public static void main(String[] args) {
        Animal cat = new Cat();
        testAnimal(cat);
        System.out.println(cat.age);
        Animal whiteCat = new WhiteCat();
        testAnimal(whiteCat);
        System.out.println(whiteCat.age);
        
    }
}

我们会发现输出的age 都是1

输出：

miao miao miao ~~
1
miao~ miao~
1

• 所以我们一般为了不混淆，会将 这个age定义为私有变量，可以提供getAge()方法访问它