Java作为面向对象的语言，可以描述一个事物的多种形态。如Student类继承了Person类，一个Student的对象便既是Student，又是Person。
Java中多态的代码体现在一个子类对象(实现类对象)既可以给这个子类(实现类对象)引用变量赋值，又可以给这个子类(实现类对象)的父类(接口)变量赋值。
定义：父类引用变量指向子类对象
多态的前提：必须有子父类关系 或者 类实现接口关系，否则无法完成多态。
在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法。
1定义与使用格式
父类类型 变量名 = new 子类类型();
变量名.方法名();
例：普通类多态：
public class Fu {
int a=1;
public void method(){
System.out.println("这是父类方法");
}
}
public class Zi extends Fu{
int a=2;
public void method(){
System.out.println("这是子类方法");
}
public void zi(){
System.out.println("这是子类方法2");
}
}
public class Test {
public static void main(String[] args) {
Fu f=new Zi();
System.out.println(f.a);
f.method();
}
}
抽象类多态：
public abstract class Animal {
public abstract void sleep();
}
public class Dog extends Animal{
public void sleep(){
System.out.println("狗趴着睡觉");
};
}
public class Test {
public static void main(String[] args) {
Animal an=new Dog();
an.sleep();
}
}
接口多态：
public interface JiDu {
public abstract void jidu();
}
public class Pig implements JiDu{
public void jidu() {
System.out.println("缉毒猪在缉毒");
}
}
public class Test {
public static void main(String[] args) {
JiDu jd=new Pig();
jd.jidu();
}
}
自己理解：
JiDu jd=new Pig();
正常建对象是 Pig p=new Pig();
这样jd和p都引用了Pig()的地址，也可以说pig()有了两种状态，这就是多态。
2 多态--成员的特点
2.1多态中成员变量的特点：
当子父类中出现同名的成员变量时，多态调用该变量时：
编译时期：参考的是引用型变量所属的类中是否有被调用的成员变量。没有，编译失败。（看父）
运行时期：调用引用型变量所属的类中的成员变量。（看父）
简单记：编译和运行都参考等号的左边。编译运行看左边。
2.2多态中成员方法的特点：
同一个父类的方法会被不同的子类重写。在调用方法时，调用的为各个子类重写后的方法。
编译时期：参考引用变量所属的类，如果类中没有调用的方法，编译失败。（看父）
运行时期：参考引用变量所指的对象所属的类，并运行对象所属类中的成员方法。（调用子）。子类独有的方法无法调用。
简单记：编译看左边，运行看右边。
3 instanceof关键字
可以通过instanceof关键字来判断某个对象是否属于某种数据类型。
例：
public class Animal{} //动物类
public class Cat extends Animal{} //猫类
public class Person extends Animal{} //人类
public class Pot{} //锅类
public class Test {
public static void main(String[] args) {
Animal an=new Person();
System.out.println(an instanceof Cat);
System.out.println(an instanceof Person);
System.out.println(an instanceof Object);
}
}
但是如果
System.out.println(an instanceof Pot); 就编译失败
所以只有同体系才能比较，不同的直接编译失败。
4多态转型
4.1向上转型
当有子类对象赋值给一个父类引用时，便是向上转型，多态本身就是向上转型的过程。
格式：
父类类型 变量名 = new 子类类型();
个人理解：double b=100;（小转大）与这个同理
4.2向下转型
一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用转为子类引用，这个过程是向下转型。
如果是直接创建父类对象，是无法向下转型的（先向上转了，才能向下转）
格式：
子类类型 变量名 = (子类类型) 父类类型的变量;
例：
public abstract class Animal{
public abstract void eat();
}
public class Cat extends Animal{
public void eat() {
System.out.println("猫吃鱼");
}
public void cathMouse(){
System.out.println("猫抓老鼠");
}
}
public class Dog extends Animal{
public void eat() {
System.out.println("狗吃骨头");
}
public void lookhome(){
System.out.println("狗看家");
}
}
public class Test {
public static void main(String[] args) {
Animal d=new Dog();
d.eat();
Animal c=new Cat();
c.eat();
Dog d2=(Dog)d;
Cat c2=(Cat)c;
d2.lookhome();
c2.cathMouse();
}
}
但是如果写成这样：
Cat c2=(Cat)d;
可以编译，但会出现异常：
所以，向下转时，必须用instanceof加个判断
public class Test {
public static void main(String[] args) {
Animal d=new Dog();
d.eat();
Animal c=new Cat();
c.eat();
method(d);
method(c);
}
public static void method(Animal an){
if(an instanceof Dog){
Dog d2=(Dog)an;
d2.lookhome();
}else if(an instanceof Cat){
Cat c2=(Cat)an;
c2.cathMouse();
}
}
}
5多态的好处与弊端
好处：隐藏了子类类型，提高了代码的扩展性
弊端：只能使用父类共性的内容，而无法使用子类特有功能，功能有限制。
6 什么时候使用
6.1什么时候使用向上转型：
当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作，这时就可以使用向上转型。
6.2什么时候使用向下转型
当要使用子类特有功能时，就需要使用向下转型。
向下转型的好处：可以使用子类特有功能。
向下转型的弊端：需要面对具体的子类对象；在向下转型时容易发生ClassCastException类型转换异常。在转换之前必须做类型判断。
7多态举例
7.1传参
public interface USB {
public abstract void openUsb();
public abstract void closeUsb();
}
public class Notebook{
public void run(){
System.out.println("笔记本运行");
}
public void shutdown(){
System.out.println("笔记本关机");
}
//usb方法，传一个usb对象
public void useUsb(USB u){
u.openUsb();
u.closeUsb();
}
}
public class Mouse implements USB{
public void openUsb() {
System.out.println("插上鼠标");
}
public void closeUsb() {
System.out.println("拔下鼠标");
}
}
public class Keyboard implements USB{
public void openUsb() {
System.out.println("插上键盘");
}
public void closeUsb() {
System.out.println("拔下键盘");
}
}
public class Test {
public static void main(String[] args) {
Notebook n=new Notebook();
Mouse m=new Mouse();
Keyboard k=new Keyboard();
n.run();
n.shutdown();
n.useUsb(m);
n.useUsb(k);
}
}
分析：这里最关键的就是：public void useUsb(USB u){}
这里参数是传一个USB类型的对象
假设当传值时，传入一个鼠标对象m（Mouse m=new Mouse();）
那么调用方法的同时，相当于实现了一个多态：
USB u=new Mouse();
这是多态最常见的应用。
之前集合ArrayList的方法Add(Object obj)，参数是一个Object类型的对象，但是实际用时，是传入一个集合中存放的对象的类型的对象（就是存什么，就传什么），这也是一种多态。
7.2 返回值
如果一个方法的返回值类型是父类，那么可以返回一个子类对象。
例：
public class Father {
public void test(){
System.out.println("父类方法");
}
}
public class Son extends Father{
public void test(){
System.out.println("子类方法");
}
}
public class Test {
public static void main(String[] args) {
Father f=methods();
f.test();
System.out.println(f instanceof Son);
System.out.println(f instanceof Father);
}
public static Father methods(){ //返回值是父类
return new Son(); //返回子类对象
}
}
8 总结：封装、继承、多态的作用
封装：把对象的属性与方法的实现细节隐藏，仅对外提供一些公共的访问方式
继承：子类会自动拥有父类所有可继承的属性和方法。（抽象类，接口都体现了继承）
多态：父类引用变量指向子类对象。配合继承与方法重写提高了代码的复用性与扩展性；如果没有方法重写，则多态同样没有意义。
扩展：java面试题，可以经常看看，例：
https://blog.csdn.net/linzhiqiang0316/article/details/80473906