目录
 
 
 
1.多态的定义
 
2.多态的三种形式
 
3.多态的编译和运行
 
4.多态的转型
 
5.多态的好处
 
6.多态的弊端
 

1.多态的定义
 
多态、封装和继承是面向对象的三大特性。多态需满足三个条件：（1）有继承；（2）有重写；（3）有父类引用指向子类对象。最终多态体现为父类引用可以指向子类对象：父类类型 变量名 = new 子类类型()。
 
2.多态的三种形式
 
（1）普通类多态定义的格式：父类类型 变量名 = new 子类类型()。
 
class Father {
    int num = 4;
}

class Son extends Father {
    int num = 5;
}

//普通类多态形式
Father father = new Son();
 
（2）抽象类多态定义的格式
 
abstract class Father {
    abstract void method();
}

class Son extends Father {
    public void method() {
        System.out.println("abstract");
    }
}

//抽象类多态表现形式
Father father = new Son();
 
（3）接口多态定义的格式
 
interface Father {
    public void method();
}

class Son implements Father{
    public void method() {
        System.out.println("implements")
    }
}

//接口多态的表现形式
Father father = new Son();
 
3.多态的编译和运行
 
（1）成员变量：编译和运行都看左边。
 
（2）成员方法：编译看左边，运行看右边。
 
4.多态的转型
 
（1）向上转型：子类对象赋值给父类对象引用。
 
使用格式：父类类型 变量名 = new 子类类型()
 
（2）向下转型：父类对象引用强制转换为子类对象引用。
 
使用格式：子类类型 变量名 = （子类类型）父类类型
 
5.多态的好处
 
（1）向上转型：隐藏了子类类型，提高代码的扩展性。
 
（2）向下转型：可以使用子类特有功能。
 
6.多态的弊端
 
（1）向上转型：只能使用父类共性的内容，无法使用子类特有功能。
 
（2）向下转型：容易发生类型转换异常（ClassCastException）。

1.方法重载
 
通常在一个类中，相同的方法对应着不同的方法实现，这些方法名相同的方法其区别在于方法参数不同。
 
2.方法重写
 
方法重写主要用于父类和子类之间，子类重写父类的方法，只是对用方法的实现不同，方法名和参数相同。
 
3.抽象类
 
在Java语言中，一个类中的方法中给出了标准，而没有给出具体的实现方法，这样的类就是抽象类。
 
4.接口
 
在多态机制中，接口比抽象类使用起来更方便，而抽象类组成的集合就是接口。

概念：同一个类实例的相同方法在不同情形下有不同的表现形式
 
在Java中，对于多态的核心表现主要有以下两点：
 
1. 方法多态：
 
① 方法重载：同一个方法名称可以根据参数的类型或个数不同调用不同的方法体
 
② 方法覆写：同一个父类的方法可以根据实例化子类的不同也有不同的实现
 
方法多态之前的文章里面详细阐述过，在此不再赘述。
 
2. 对象多态：
 
① 向上转型(90%)：
 
天然发生，认爹过程，指的是将子类对象变成父类对象
 
语法：父类 父类引用 = 子类实例;，例如Person per = new Student();
 
class Person {
    public void print() {
        System.out.println("父类");
    }
}
class Student extends Person {
    public void print() {
        System.out.println("子类");
    }
}
public class XiangShangZhuanXing {
    public static void main(String[] args) {
        Person per = new Student();
        per.print();
    }
}
 
 
 结论：不管是否发生了向上转型，核心本质还是在于：你使用的是哪一个子类(new在哪里)，而且调用的方法是否被子类所覆写了。
 
应用场景：参数统一化
 
例如：要求定义一个方法，这个方法可以接收Person类的所有子类实例，并调用Person类的方法。
 
class Person {
    public void print() {
        System.out.println("1.我是人类！");
    }
}
class Student extends Person {
    public void print() {
        System.out.println("2.我是学生！");
    }
}
class Worker extends Person {
    public void print() {
        System.out.println("3.我是工人！");
    }
}
public class CanShuTongYiHua {
    public static void main(String[] args) {
        //Person per = new Student();
        WhoYouAre(new Student());
        //Person per = new Worker();
        WhoYouAre(new Worker());
    }
    public static void WhoYouAre(Person per) {
        per.print();
    } 
}
 
 
② 向下转型(1%)：
 
需要强转，指的是将父类对象变成子类对象
 
语法：子类 子类实例 = (子类)父类实例;，例如Student stu = (Student) per;
 
 
问题：向下转型存在的意义或者为什么我们需要向下转型？
 
 
class Person {
    public void print() {
        System.out.println("父类");
    }
}
class Student extends Person {
    public void print() {
        System.out.println("子类");
    }
    public void fun() {
        System.out.println("只有子类有");
    }
}
public class XiangXiaZhuanXing {
    public static void main(String[] args) {
        Person per = new Student();
        per.print();
        System.out.println("==========");
        Student stu = (Student) per;
        stu.fun();
    }
}
 
 
 结论：在上述代码中父类能调用的就只有本类定义好的方法，并没有Student类中的fun()方法，如果父类要想调用fun()方法就只能进行向下转型处理，总的来说就是当需要子类扩充操作的时候就要采用向下转型。
 
应用场景：发生在父类引用需要调用子类扩充方法时，才发生向下转型变为子类引用调用其扩充方法
 
 
 
注意：并不是所有的父类对象都可以向下转型 ，如果要想进行向下操作之前，前提是一定要首先发生向上转型，否则在转型时会出现ClassCastException(运行时异常，类型转换异常，发生在两个毫无关系的两个类之间的强转时)
 
 
观察错误转型：
 
class Person {
    public void print() {
        System.out.println("父类");
    }
}
class Student extends Person {
    public void print() {
        System.out.println("子类");
    }
    public void fun() {
        System.out.println("只有子类有");
    }
}
public class XiangXiaZhuanXing {
    public static void main(String[] args) {
        Person per = new Person();
        per.print();
        System.out.println("==========");
        Student stu = (Student) per;
        stu.fun();
    }
}
 
 
 结论：上述代码进行向下转型之前Person per = new Person();没有先进行向上转型，所以出现类型转换异常这个错误。
 
问题 ：如果向下转型存在安全隐患，那么如何转型才靠谱呢？
 
 
最好的做法就是先进行判断，而后再进行转型，那么就可以依靠关键字instanceof实现。
 
引用对象 instanceof 类：表示该引用能指向该类，返回true表示可以指向，返回flase表示不能指向。
 
因此，向下转型的标准格式为：
 
if(!(per instanceof Student)) {
	per = new Student();   // 先建立起联系
}
Student stu = (Student) per;
 
观察instanceof操作：
 
class Person {
    public void print() {
        System.out.println("父类");
    }
}
class Student extends Person {
    public void print() {
        System.out.println("子类");
    }
    public void fun() {
        System.out.println("只有子类有");
    }
}
public class XiangXiaZhuanXing {
    public static void main(String[] args) {
        Person per = new Person();
        //避免ClassCastException
        if(!(per instanceof Student)) {
            per = new Student();
        }
        Student stu = (Student) per;
        stu.fun();
    }
}
 
 
 结论：我们可以看到加上instanceof之后就算没有先向上转型，向下转型依然是可以进行的。
 
总结：
 
对象的多态性(向上转型或向下转型)本质在于方法的覆写。
通过对象的向上转型可以实现接收参数的统一，向下转型可以实现子类扩充方法的调用(一般不操作向下转型，有安全隐患)。
两个没有关系的类对象是不能够进行转型的，一定会出现ClassCastException。

 
目录
 
1. 问题
2. 解答

 
 
1. 问题
 
泛型是多态的表现形式吗？
 
 
2. 解答
 
不是，泛型不认多态，定义什么泛型就必须要输入什么类；
多态是描述类与类的关系的，一定是有对象的，而泛型没有创建对象，只是限制能传入什么数据类型的对象；
下例中，是 List 的多态而不是泛型的多态：
 
import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        List<String> ll = new ArrayList<String>;
    }
}
 
容易混淆的是泛型参数的向上限定：<? extends 类 > 能接收该类型及其子类，但因为父类在多态里，没涉及到对象，所以不是多态，例如：
 
import java.util.ArrayList;

class People {

}

class Man extends People {

}

public class Test {
    public static void main(String[] args) {
        ArrayList<? extends People> l = new ArrayList<Man>();
    }
}
 
总结：泛型没有多态，多态是指 父类变量 = 子类对象，而泛型只是一个标签；