前言
** 本篇博客 博主来介绍 Java的三大特性的最后一个 特性 —— 多态；**
** 当然，也包括多态所涉及的多方面内容；**
** 现在，拉长耳朵，提高警觉，端起你们的小板凳；**
** 且听我细细道来......**
思维导图
一、多态的概念
** 多态，**
** 从语文的层次上来说：一种事务，多种形态；这句话不算对，但也不算错；**
** 但是，我们需要从程序的角度上来介绍：去完成某个行为，当不同的对象去完成时，会产生不同的状态，这就是多态。**
** 比如说，如下图所示：同样是一个打印机，去打印相同的照片；但是，交给彩色打印机打印出来的就是彩色的照片；交给黑白打印机打印出来的就是黑白照片；它们完成的动作都是“打印”；这就是一种多态；**
** 再比如说，如下图所示，去“吃饭”，对于小猫来说，吃的是“猫粮”；但对于小狗来说，吃的确是“狗粮”；他们完成的都是“吃饭”这个行为，但是却“吃出不同的结果来”； 这也是一种多态；**
**总的来说，同一件事情，发生在不同的对象上，会产生不同的结果。 **
听到这里，是不是还是对于 多态 有点头晕；
那么，要想真正了解多态，我们还是需要从三个方面来介绍：
- 什么是向上转型；
- 什么叫做方法重写；
- 了解了前两个，我们才会真正了解什么是多态。
下面，我会一一的介绍......
二、向上转型和向下转型
2.1 向上转型
** 当然的是，有了 向上转型，那么肯定也会有向下转型，**
向下转型 会在后面讲到......
2.2 什么是向上转型
** 首先介绍一段平平常常的继承代码：**
package Demo1;
class Animal {
public String name;
public int age;
public void eat() {
System.out.println(this.name+"吃饭！");
}
}
class Cat extends Animal {
public String hair;
public void mew() {
System.out.println(this.name+"正在叫!");
}
}
public class TestDemo1 {
public static void main(String[] args) {
Cat cat = new Cat();
cat.mew();
}
}
** 那么，如果现在抛开 继承 不谈，直接用Animal类 new一个animal对象，可以发现，animal对象访问不了Animal类 里面没有的成员变量 或成员方法：**
** 接下来，可以来讲一讲 向上转型 的知识了：**
** 这里的 上 指的是 父类，那么 下 指的就是 子类；**
** 那么，把子类给父类是什么意思呢？**
//即：定义类一个 cat
//可以用animal来接收
//也就是说，父类的引用 可以用来引用 子类的对象
Cat cat = new Cat();
Animal animal = cat;
//也就是说，上面的两行代码，可以合并成下面一行代码
Animal animal = new Cat();
//此时，父类的引用 引用了 子类的对象，我们把这个就叫做 向上转型
** 但是，此时又有一个新的问题；**
** animal的类型是Animal，那么 此时它只能去访问 类Animal 的成员变量和方法，去访问 子类Cat的成员变量或方法的时候会报错：**
【总结】
** 向上转型，把原来的 子类的类型 转换成了 父类的类型，那么，就只能去访问 父类特有的成员方法或者成员变量。**
2.3 三种常见的向上转型
2.3.1 直接赋值
** 所谓直接赋值，就是 上面的直接把 子类对象 给 父类 进行引用：**
/*
Cat cat = new Cat();
Animal animal = cat;
*/
Animal animal = new Cat();
2.3.2 作为方法的参数
2.3.3 作为方法的返回值
2.4 向下转型（这个了解即可）
前面已经介绍过 向上转型，那么 现在来介绍一下 向下转型：
不过，现在来执行一下这样的操作：
此时，运行结果：
但是，向下转型不安全（不介意使用向下转型）：
** 我们还需要做以下修改 以保证其安全性：**
【注意】
三、方法重写
** 由上面可知，父类引用引用了子类的对象；**
** 但是，在现实生活中，猫是吃猫粮的；**
** 那么，如果想改的话，肯定不可以在父类上面进行修改的；**
** 毕竟，可能还有 其他的子类 来继承父类；**
** 那么，如果想修改的话，就需要在子类里面重新取实现一遍这个方法的：**
** 然后，我们来对比一下 实现前后的结果：**
没有在子类里面写eat方法：
在子类里面写了eat方法：
这是怎么回事呢？
——这就是马上所要介绍的方法重写。
3.1 方法重写的概念
** 重写，也称为覆盖；**
** 重写，是子类对父类 非静态、非private修饰、非final修饰、非构造方法 等的实现过程进行重新编写；**
** 重写的好处是：子类可以根据需要，定义特定的属于自己的行为；如 上面的猫可以吃猫粮，狗可以吃狗粮。**
3.2 方法重写的规定
方法重写满足以下三个条件：
- 方法的名称相同；
- 方法的返回值相同；
- 方法的参数列表相同。
** 当在子类 方法重写以后，那么就会调用的是 子类重写的内容。**
** 我们把这个现象叫做动态绑定（这是多态的基础）**
** 传送门：动态绑定**
** 在上面所示例中，**
** 在编译的时候，调用的还是 父类Animal的eat方法；**
** 但是，在运行的时候，变成了子类Cat自己的eat方法；**
** 因此，动态绑定又称为 运行时绑定，**
** 即：在程序运行的时候才知道要调用谁。**
** 当然，有了 动态绑定，那肯定也有 静态绑定：**
** 在编译期间就已经知道了 要调用的是谁，**
** 比如说 重载。**
3.3 在IDEA中使用重写的快捷方式
** 当然，在使用IDEA编译器的时候 ，**
** 重写不仅仅可以直接在子类上手敲出来的（上面的就是），而且还可以使用快捷键的方式：**
【注意】上面的 @Override 就是重写的意思。
3.4 方法重写中所要注意的细节
- 静态方法（static修饰）是构成不了重写的：
- private修饰 的方法不能进行重写：
- 如果要进行重写的话，那么 子类的 访问限定修饰符的权限 一定 大于等于 父类的访问限定修饰符：
- 被final修饰的方法不可以进行重写：
- 子类和父类在同一个包中，那么子类可以重写父类的所有方法（除了 声明为private和final的方法）；子类和父类不在同一个包，那么子类只能够 重写父类的 声明为public和protected的非final的方法（即 默认权限方法/包访问权限 不可以被重写）；
- 重写的方法，可以使用 @Override 注解来显示指定；有了这个注解 可以帮助我们进行一些合法性校验；如 不小心把方法名字写错了（写成ate），那么此时编译器就会发现父类中没有ate方法，就会编译报错，提示无法构成重写。
** 访问限定符权限大小比较：**
**private < default < peotected < public **
四、多态
4.1 什么是多态
类的实现者所写的代码：
class Animal {
public String name;
public int age;
public void eat() {
System.out.println(this.name+"吃饭！父类Animal");
}
}
class Cat extends Animal {
public String hair;
public void eat(){
System.out.println(this.name+"吃猫粮！");
}
public void mew() {
System.out.println(this.name+"正在叫!");
}
}
class Dog extends Animal {
public void eat(){
System.out.println(this.name+"吃狗粮！");
}
}
类的调用者所写的代码：
public static void function(Animal animal) {
animal.eat();
}
public static void main(String[] args) {
Cat cat = new Cat();
Dog dog = new Dog();
function(cat);
function(dog);
}
所以运行之后得到的结果不一样：
** 从上面可以得到，同一个方法，当引用的对象不一样的时候，这个方法所表现出来的行为是不一样的；**
** 我们把这种思想就叫做 多态。 **
4.2 多态产生的前提
- 发生向上转型：父类引用 引用子类的对象；
- 发生重写：父类和子类当中 有同名的覆盖方法；
- 通过父类引用，调用这个重写的方法，此时会发生 动态绑定。
思想：通过一个引用调用一个方法，由于引用的对象不同，所执行的行为也是不一样的；我们把这种思想就叫做多态的思想。
五、理解多态
现在再次回顾一下多态：
场景：现在想画一个图形（图形是未知的）：
首先，创建父类：
class Shape {
//省略了长、宽、高等之类的属性
public void draw(){
System.out.println("画图形！！！！！！");
}
}
创建父类Shape只是画父类，但是并没有说明画什么；
现在想画各种各样的图形，那么就可以去重写 Shape类里面的draw方法来满足自己的需求：
class Cycle extends Shape {
@Override
public void draw() {
System.out.println("○");
}
}
class Rect extends Shape {
@Override
public void draw() {
System.out.println(" ⃟ ");
}
}
class Triangle extends Shape {
@Override
public void draw() {
System.out.println("△");
}
}
前面两段代码都是类的实现者写的；
当有一天作为用户、作为类的调用者 想要画出这些图形，那么就可以这样来做：
public static void drawMap(Shape shape) {
shape.draw();
}
public static void main(String[] args) {
Cycle cycle = new Cycle();
Rect rect = new Rect();
Triangle triangle = new Triangle();
drawMap(cycle);
drawMap(rect);
drawMap(triangle);
}
那么，根据引用的对象不一样，draw方法所表现的行为就不一样；
这个就叫做 多态。
代码示例结果：
由此可见，多态只是一种思想，需要满足三个条件；
那么，多态到底有什么好处呢？
——其拓展能力非常强：
如果突然说，现在想要画一朵花：
那么只需要在这样做即可：
class Flower extends Shape {
@Override
public void draw() {
System.out.println("✿");
}
}
测试类添上这个来测试：
drawMap(new Flower());
代码示例结果：
六、多态的优缺点
6.1 使用多态的好处
（1）能够降低代码的 "圈复杂度" ，避免使用大量的 if-else语句；
** 传送门——圈复杂度**
** 说白了，可以简单粗暴的计算 一段代码中条件语句和循环语句 出现的个数，这个个数就称为 "圈复杂度"；**
** 如果一个方法的 圈复杂度 太高，就需要考虑重构。**
**（2）可扩展能力强； **
** 就是上面所说的 添加了一朵花的 示例。**
6.2 多态的缺点
** 代码的运行效率低。**
七、避免在构造方法中调用重写的方法
class B {
public B(){
func();
}
public void func() {
System.out.println("B.func() ");
}
}
class D extends B {
D(){
super();
}
@Override
public void func() {
System.out.println("D.func() ");
}
}
public class Test {
public static void main(String[] args) {
D d = new D();
}
}
代码示例结果：
** 【说明】**
- 构造D对象的同时，会调用B的构造方法；
- B的构造方法中调用了 func方法，此时会触发 动态绑定，会调用到D中的 func；
【注意】最好尽量不要写类似的代码——避免在构造方法中调用重写的方法。
写在最后
** 到现在，Java三大特性的最后一个特性——多态思想 就已经告一段落了；**
** 由于博主水平有限，可能会出现一些表达不清楚，或者出现一些其他的情况，**
** 欢迎各位铁汁们指出来，和博主一起改正，**
** 一起努力，共同进步；**
** 好了，如果这篇博客对铁汁们有帮助的话，可以送一个免费的 赞 嘛；**
** 当然，顺手点个关注是再好不过的了......**
版权归原作者 哎呀是小张啊 所有， 如有侵权，请联系我们删除。