一、什么是多态？

多态的词组字面意思是： 某种事物多种形态。
但是对于我们学习Java 的程序原来说，就不不能简单这样来理解了。
多态是 完成某个行为，不同的对象去实现会有不同的效果。现在还看不懂其实没关系，也就简单提一嘴。

举个栗子：

有一天，学校二食堂做了一大盘深海大闸蟹，你和小帅同时在排队。此时一位长得very beautiful 的女生——小美来了，到窗口看了一下菜，感觉不错，也想吃。但是排队的人太多了，就想插下队。你一看，我丢想插队，门都没有，表现出不肯的样子。而你后面的小帅眼睛一亮，就说，小美同学你好，我看你插队的话影响不好，不如我多打一份给你，倒时候加个微信发我就行了。此时这就是多态，不同的人对一件事表现出不同的状态。到头来‘你’还在为什么，自己还单身着。小帅到后面，小美微信也加了，说：就一顿饭钱也没多少，算了算了。此时小美就非常感动，说：小帅同学下次我会请你吃一顿。这样一来而去。。。

磨刀不误砍柴功，要想学真正学会多态，就要理解一下，向上转型是怎么转的？静态绑定是怎么绑定的，方法的覆盖是？最后，学完才可以说学会了Java 的多态，太哇塞了！！！

二、转型

向上转型

向上转型： 父类 引用 子类型对象
也好理解 儿子孝顺父亲，给父亲买点礼物，父亲乐意地接受了。

例子：创建一个父类 Animal 其子类有Dog， Cat
测试类 Test

public class Animal {public String name;//无参构造方法public Animal() {}//有参构造方法public Animal(String name) {this.name = name;}//动物会说方法public void speak() {System.out.println("会说话-----------");}}

public class Cat extends Animal{//无参构造方法public Cat() {}//有参构造方法public Cat(String name) {super(name);//子类继承父类，就要先对父类进行初始化}public void speak() {System.out.println(this.name+"会喵喵叫-----");}}

public class Dog extends Animal{//无参构造方法public Dog() {}//有参构造方法public Dog(String name) {super(name); //子类继承父类，就要先对父类进行初始化}public void speak() {System.out.println(this.name+"会汪汪叫------");}//dog 特有的方法public void lookHouse() {System.out.println(this.name+"会看家-----------");}}

public class Test {public static void main(String[] args) {Animal dog = new Dog("小黑");dog.speak();Animal cat = new Cat("小咪");cat.speak();}
}

有三种表示方式
1.直接赋值

2.方法传参

3.返回值

总结
优点 父类可以接受任何的子类

又创建了一个Cat 类 ，也是可以接受的。

缺点 不能调用子类特有方法，因为你还是Animal 类！

向下转型

父类强转子类

Animal 转为 Dog子类
a instanceof b ： 判断 a 是否为b类型 。是返回 true ,否返回false

public class Test {public static void main(String[] args) {Animal animal = new Dog("小黑");if(animal instanceof Dog) { Dog dog = (Dog)animal;//可以 调用子类特有的方法dog.lookHouse();}}
}

注意了 强转是要注意 子类一致
一开始是狗，怎么强转成猫呢？
就像养一只小狗，再怎么养，也不会变成小猫。因为一生下来就决定了的。

public class Test {public static void main(String[] args) {Animal animal = new Dog("小黑");Cat cat = (Cat) animal; //errorcat.speak(); //error}
}

总结：

三、方法覆盖与方法重载

方法重载： 我想大家都应该知道：就是在同一个类中，方法名相同，参数列表不同。就只要记住一个方法名，就可以调用不同的参数列表，提高了效率。

以add() 加法为例子：

public class Test {public static void main(String[] args) {System.out.println("方法重载");//相同 add方法名，不同参数列表。构成方法重载System.out.println(add(1,5));System.out.println(add(1,2,3));}public static int add(int a,int b) {return a+b;}public static int add(int a,int b,int c) {return a+b+c;}
}

方法覆盖: 也叫方法重写。发生在父子类之间的关系，方法名相同，参数列表相同，返回值也要相同。
也好理解，重写是重新再写一遍呗，不改变原来的。
父类的方法完成不了子类的需求，就要重写。

方法覆盖也存在一些细节：
1.static ，final ，private 修饰的方法，构造方法 不能被重写。
2.子类重写的方法，访问权限要 >= 父类 原来的方法。
3.重写方法的返回值类型也可不同，但是要构成父子类关系。

四、绑定

动态绑定

动态绑定是理解多态的基础。
那什么是动态绑定呢？
程序在编译的时候，确实是调用了父类的方法。但在运行的时候，通过父类的引用，调用的却是子类重写父类的那个方法。这就叫动态绑定。

还是以之前的Animal ，Dog 为例子：
不是输出： 会说话-------

静态绑定

“静态绑定"也称为"早期绑定”。
简单 就相当于平时调用方法 。就是调用这个方法时，编译器确定调用这个方法。

public class Test {public static void main(String[] args) {Test test = new Test();test.func(); //确定调用func()}public  void func() {System.out.println("我就是一个普通的方法------");}
}

五、理解多态

现在，我们学习了
向上转型 就是父类型 引用 子类型对象 ，方法的重写是 父类的方法完成不了子类的需求，就要重写。 静态绑定：运行是调用子类重写父类的方法。

请看

public class Test {public static void main(String[] args) {Animal dog = new Dog("小黑");Animal cat = new Cat("小花");autoSpeak(dog);autoSpeak(cat);}public static void autoSpeak(Animal animal) {animal.speak();}
}

autoSpeak() 方法就会自动的调用 子类的speak（）方法。
不要判断 是否为 Dog 类 还是 Cat 类。
1.能够降低代码的 “圈复杂度”, 避免使用大量的 if - else
2.可扩展能力强。