java语言中多态语法机制：
1.例如有a、b、c三个类，b继承a，c继承a，ab之间无任何关系

2.面向对象三大特征:封装、继承、多态

3.在多态中涉及到的几种概念：
向上转型：子类型转父类型，又被称为自动类型转换
向下转型：父类型转子类型，又叫强制类型转换，需要加强制类型转换符
两种类型间必须为继承关系。
4.实现多态的三个必要条件：
要有继承、要有重写、父类引用指向子类对象向上转型示例代码：

public class Controller {
    public static void main(String[] args) {
        Father father = new Father();
        father.money();

        son son = new son();
        son.money();

        grandson grandson = new grandson();
        grandson.money();
//以下为多态语法机制
        Father a1 = new son();//继承父亲的儿子类
        a1.money();//这里的money方法是指father类这个父类中的money方法

        //在运行时，还是会去找构造方法中的类，即儿子，所以出来的是儿子的钱
        /*
        1.java程序分为编译阶段与运行阶段

        2.先分析编译阶段，再分析运行阶段，编译无法通过

        3.编译阶段编译器检查a1这个引用的数据类型为父类型，由于父类型中有
        这个money方法，所以编译通过，这个过程我们称为静态绑定，

        4.在程序运行阶段，jvm堆内存当中真实创建的对象是son对象，
        那么程序在运行阶段时一定会调用son对象的money方法，此时发生了
        程序的动态绑定，运行阶段绑定

        5.无论是子类有没有重写money方法，运行阶段一定调用的是子类的方法，
        因为底层真实对象就是子类对象

        6.f父类型引用纸箱子类型对象这种机制导致程序存在编译阶段绑定和运行阶段绑定
        两种不同形态/状态，这种机制可以成为一种多态语法机制
       */
    }

}
public class Father {
    public void money(){
        System.out.println("父亲的钱");
    }
}
//儿子继承父亲
class son extends Father{
    public void money(){
        System.out.println("儿子的钱");
    }

}
//孙子继承父亲，孙子与儿子间无关系
class grandson extends Father{
    public void money(){
        System.out.println("孙子的钱");
    }

}

向下转型（强制转换）：
需求：需要对象执行父类中没有的方法怎么办
对象是无法直接调用父类型中没有的方法
我们可以将对象强制类型转换为子类型
对象的类型是父类转换为子类，被称为向下转换（强制类型转换），仍需要两个类型间为继承关系。

什么时候需要向下转换呢？
当调用的方法是子类型中特有的，在父类型中不存在，必须进行向下转型
强制类型转换：
父类型 对象 = new 子类型();
子类型 对象 = (子类型)对象;

为了防止强制报错，引入instanceof，中文意思是“实例的”

多态在实际开发下的作用
示例：
测试类：

public class Test {
    public static void main(String[] args) {
        //创建主人对象
        //feed方法是主人类的方法
        Master master = new Master();
        //创建猫对象
        Cat cat = new Cat();
        //主人喂猫
        master.feed(cat);

        //创建狗对象
        Dog dog = new Dog();
        //主人喂狗
        master.feed(dog);

        //创建蛇对象
        Snake snake = new Snake();
        //喂蛇
        master.feed(snake);

    }
}

动物类的父类Pet：

public class Pet {
    //由该父类，提供eat方法
    public void eat(){

    }
}

主人类（是pet类的父类）：

public class Master {
    /*
    Master主人类面向的是一个抽象的Pet，不再面向具体宠物
    面向抽象编程，不要面向具体对象编程
    解耦合，扩展力强
     */
    public void feed(Pet pet){//Pet pet是一个父类型的引用
        pet.eat();
    }
}

其他子类：

public class Dog extends Pet {
    public void eat(){//继承pet的eat方法
        System.out.println("狗吃骨头");
    }
}
public class Snake extends Pet{
    public void eat(){//继承pet的eat方法
        System.out.println("蛇吞xiang");
    }
}
public class Cat extends Pet{
    public void eat(){//继承pet的eat方法
        System.out.println("猫吃鱼");
    }
}

一个方法名，参数不同，这叫方法重载。(Overload)void foo(String str);
void foo(int number);父类与子类有同样的方法名和参数，这叫方法覆盖。(Override)

class Parent {
    void foo() {
        System.out.println("Parent foo()");
    }
}
class Child extends Parent {
    void foo() {
        System.out.println("Child foo()");
    }
}

父类引用指向子类对象，调用方法时会调用子类的实现，而不是父类的实现，这叫多态。

Parent instance = new Child();
instance.foo(); //==> Child foo()

我理解的多态与继承体系有关，与方法覆盖有关，与方法重载无关。