多态是继封装、继承之后，面向对象的第三大特性。
可以理解为一个事物的多种形态。通过不同的事物，体现出来的不同的形态。多态，描述的就是这样的状态。如跑的动作，每个动物的跑的动作就是不一样的。
多态：是指同一行为，具有多个不同表现形式。
（1）继承或实现【二选一】；
（2）方法的重写【意义体现：不重写，无意义】
（3）父类引用指向子类对象【格式体现】
多态性，是面向对象中最重要的概念，在 Java 中的体现：
对象的多态性：父类的引用指向子类的对象；（可以直接应用在抽象类和接口上）
（1）本态引用：左边的变量与右边的对象是同一种类型；
（2）多态引用：左边的变量是父类类型，右边的对象是子类的对象；
特征：编译类型与运行时类型不一致；
编译的时候，按照父类的类型进行编译的；
执行的方法，按照子类类型运行，是“执行子类重写的方法”。
口诀：编译看左边，运行看右边。
注意：多态强调的是方法的动态绑定，即多态与属性无关，只说方法。
Java 引用变量有两个类型：编译时类型 和 运行时类型。
编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。
简称：编译时，看左边；运行时，看右边。
若编译时类型和运行时类型不一致，就出现了对象的多态性（Polymorphism）
多态情况下：“看左边”：看的是父类的引用（父类中不具备子类特有的方法）
“看右边”：看的是子类的对象（实际运行的是子类重写父类的方法）
有了对象的多态性以后，在编译期，只能调用父类中声明的方法，但在运行期间我们实际执行的是子类重写父类的方法。
口诀：编译看左边，运行看右边。
（1）类的继承关系；
（2）方法的重写；
在Java中，子类的对象可以替换父类的对象使用：
（1）一个变量只能有一种确定的数据类型；
（2）一个引用类型变量可能只需（引用）多种不同的类型的对象；
Demo：
1 Person p = new Student();
2 Object o = new Person(); //Object类型的变量o，指向Person类型的对象
3 o = new Student(); //Object类型的变量o，指向Student类型的对象
子类可看做是特殊的父类，所以父类类型的引用可以执行子类的对象：向上转型（upcasting）。
一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法。
Demo：
1 Student m = new Student();
2 m.school = “pku”; //合法,Student类有school成员变量
3 Person e = new Student();
4 e.school = “pku”; //非法,Person类没有school成员变量
注意：属性是在编译是确定的，编译是 e 是 Person类型，没有 school 成员变量，因而编译错误。
Demo：方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法
1 public class Test {
2 public void method(Person e) {
3 // ……
4 e.getInfo();
5 }
6 public static void main(Stirng args[]) {
7 Test t = new Test();
8 Student m = new Student();
9 Teacher te = new Teacher();
10 t.method(te);
11 t.method(m); // 子类的对象m传送给父类类型的参数e
12 }
13 }
（1）正常的方法调用
1 Person e = new Person();
2 e.getInfo();
3 Student s = new Student();
4 s.getInfo();
（2）虚拟方法调用（多态情况下）
子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。
1 Person p = new Student();
2 p.getInfo(); //调用Student类的getInfo() 方法
（3）编译时类型和运行时类型
编译时 p 为 Person类型，而方法的调用是在运行时确定的，所以调用的是 Student 类的 getInfo() 方法。——动态绑定。
注意：多态是在运行时期的！
对象的多态性，只是适用于方法，不适用于属性（即：编译看左边，运行看左边）
Demo：
1 public class Person {
2 String name;
3 int age;
4
5 int id = 1001;
6
7 public void eat(){
8 System.out.println("人：吃饭");
9 }
10
11 public void walk(){
12 System.out.println("人：走路");
13 }
14 }
15 public class Man extends Person{
16
17 boolean isSmoking;
18
19 int id = 1002;
20
21 public void earnMoney(){
22 System.out.println("男人负责挣钱养家");
23 }
24
25 public void eat(){
26 System.out.println("男人多吃肉，长肌肉");
27 }
28
29 public void walk(){
30 System.out.println("男人霸气的走路");
31 }
32 }
33
34 public class PersonTest {
35 public static void main(String[] args) {
36 Person p1 = new Person();
37 p1.eat();
38
39 Man man = new Man();
40 man.eat();
41 man.age = 25;
42 man.earnMoney();
43
44 System.out.println("*******************");
45 //对象的多态性：父类的引用指向子类的对象
46 Person p2 = new Man();
47 // Person p3 = new Woman();
48 //多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用
49 p2.eat();
50 p2.walk();
51
52 // p2.earnMoney();
53
54 System.out.println(p2.id);//1001
55
56 }
57 }
提高了代码的通用性，常称作接口重用；
（1）需要存在继承或者实现关系
（2）有方法的重写
编译时：要查看引用变量所声明的类是否有所调用的方法；
运行时：调用实际 new 的对象所属的类中的重写方法；
口诀：编译看左边，运行看右边。
成员变量不具备多态性，只看引用变量所声明的类。
口诀：编译看左边，运行看左边。
重载，是指允许存在多个同名方法，而这些方法的参数不同。 编译器根据方法不同的参数表， 对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。 它们的调用地址在编译期就绑定了。 Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。
所以： 对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定” ；而对于多态，只有等到方法调用的那一刻， 解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定” 。
引用一句Bruce Eckel的话： “不要犯傻，如果它不是晚绑定， 它就不是多态。”
原文：https://www.cnblogs.com/niujifei/p/13911870.html