导学

本章节，我们将要学习面向对象三大特性之一的多态，所谓的多态，字面意义来看就是多种形态。它是面向对象程序设置的最核心的特征。从某种意义上来讲，封装和继承都是为了多态而准备的。

多态的概念

在现实生活中，动物都有吃东西，跑和跳等通用的行为能力，但是不同的动物针对行为的表现形式是不同的。比如猫，狗，兔子喜欢吃的东西各有不同，而叫声也是不一样的。
6. 多态 - 图1
再比如键盘上的f1键，在eclipse的界面会唤出eclipse的帮助文档，在word的界面会唤出word的帮助文档，在Windows系统下回唤出Windows的帮助文档。可以看到同样的行为在不同的对象上会产生不同的形式结果，这就是生活中的多态。
在程序中：

多态意味着允许不同类的对象对同一消息作出不同的响应。

在Java中，多态在广义上来说可以分为编译时多态（方法的多态性）和运行时多态（对象的多态性）。

  1. 1. 编译时多态（也叫设计时多态，通过方法重载实现）
  2. 2. 运行时多态（程序运行时动态决定调用哪个方法）

在Java中指的多态，大多指的是运行时多态（狭义上的多态）。
多态实现的具体条件在于：

  1. 满足继承关系
  2. 父类引用指向子类对象，例如Animal animal = new Dog();

在构建对象时，等号左边称为对象的引用，右边称为对象
造成多态的原因：在堆内存的存储中，子类对象的内存空间套上了一层父类的类型
那么，什么是父类引用指向子类对象呢？接下来通过具体代码来看看吧

多态的实现

场景描述及实体类编写

6. 多态 - 图2

  1. package com.dodoke.proJ.animal;
  2. public class Animal {
  3.     //属性：昵称、年龄
  4.     private String name;
  6.     private int month;
  8.     //方法：吃东西
  9.     public void eat() {
  10.         System.out.println("动物都有吃东西的能力");
  11.     }
  13.     public String getName() {
  14.         return name;
  15.     }
  16.     public void setName(String name) {
  17.         this.name = name;
  18.     }
  19.     public int getMonth() {
  20.         return month;
  21.     }
  22.     public void setMonth(int month) {
  23.         this.month = month;
  24.     }
  25.     public Animal(String name, int month) {
  26.         super();
  27.         this.name = name;
  28.         this.month = month;
  29.     }
  31.     public Animal() {
  32.         super();
  33.     }
  35. }
  1. package com.dodoke.proJ.animal;
  2. public class Cat extends Animal {
  3.     //属性：体重
  4.     private double weight;
  5.     //方法：跑动
  6.     public void run() {
  7.         System.out.println("小猫快乐的奔跑");
  8.     }
  10.     //方法：吃东西
  11.     @Override
  12.     public void eat() {
  13.         System.out.println("猫吃鱼~");
  14.     }
  16.     public double getWeight() {
  17.         return weight;
  18.     }
  19.     public void setWeight(double weight) {
  20.         this.weight = weight;
  21.     }
  23.     public Cat() {
  24.         super();
  25.     }
  26.     public Cat(String name, int month, double weight) {
  27.         super(name, month);
  28.         this.weight = weight;
  29.     }
  30. }
  1. package com.dodoke.proJ.animal;
  2. public class Dog extends Animal{
  3.     //属性：性别
  4.     private String sex;
  6.     //方法：睡觉
  7.     public void sleep() {
  8.         System.out.println("小狗有午睡的习惯");
  9.     }
  11.     //方法：吃东西
  12.     @Override
  13.     public void eat() {
  14.         System.out.println("狗吃肉~");
  15.     }
  16.     public String getSex() {
  17.         return sex;
  18.     }
  19.     public void setSex(String sex) {
  20.         this.sex = sex;
  21.     }
  23.     public Dog() {
  24.         super();
  25.     }
  26.     public Dog(String name, int month, String sex) {
  27.         this.setMonth(month);
  28.         this.setMonth(month);
  29.         this.sex = sex;
  30.     }
  31. }

多态是指编译时类型和运行时类型不一致

Java引用类型变量有两种类型：一种是编译时类型，一种是运行时类型

  • 编译的类型是由声明变量的时候确定的（声明变量类型）

  • 运行时的类型是由实际上赋给该变量的对象决定的（赋给该变量的对象类型）

    1. //比如声明变量类型为Animal，实际赋给该变量的对象类型为Dog
    2. Animal animal = new Dog();

    向上转型

    向上转型是指**父类引用指向子类对象**
    通常也称向上转型为隐式转型和自动转型。通俗来说，是子类转型为父类，小类转型为大类。

    1. public class Test {
    2.   public static void main(String[] args) {
    3.       //animal的引用  = 具体的animal实例
    4.       Animal one = new Animal();
    5.       Animal two = new Cat();
    6.       Animal three = new Dog();
    8.       one.eat();
    9.       two.eat();
    10.       three.eat();
    12.       one.getMonth();
    13.       two.getName();
    14.       //three.sleep();
    15.   }
    16. }

    父类引用指向子类实例，可以调用子类重写父类的方法以及父类派生的方法，但是无法调用子类独有方法！ 父类中的静态方法无法被重写，所以向上转型后，只能调用到父类原有的静态方法

向下转型

向下转型指的是**子类引用指向父类对象**
向下转型又称之为强制类型转换，通俗来讲就是父类转型为子类，大类转为小类。对比之前的基本数据类型转换，数据范围大的类型转为数据范围小的类型就需要进行强制类型转换，引用数据类型也是如此。

  • 当引用数据类型发生强制转换的时候，要转换对象的实际类型必须和要转化成的类型完全一致

    1. public class Test {
    2.   public static void main(String[] args) {
    3.       //animal的引用  = 具体的animal实例
    4.       Animal one = new Animal();
    5.       Animal two = new Cat();
    6.       Animal three = new Dog();
    8.       one.eat();
    9.       two.eat();
    10.       three.eat();
    12.       one.getMonth();
    13.       two.getName();
    14.       //three.sleep();
    16.       System.out.println("=======================================");
    17.       Cat temp = (Cat)two;
    18.       temp.eat();
    19.       temp.run();
    20.       temp.getMonth();
    22.       /**
    23.        * 此处的代码不能进行强制类型转换
    24.        * 原因：two这个对象定义的时候，实际上指向的是Cat这个类型的空间
    25.        * Cat temp = (Cat)two; 相当于把two对象还原成原来的实例空间。
    26.        * 但是狗和猫并没有兼容的关系，只是拥有同一个父类而已，是兄弟关系
    27.        */
    28.       Dog temp1 = (Dog)two;//必须满足转型条件才能转换
    29.       temp1.eat();
    30.       temp1.sleep();
    31.       temp1.getMonth();
    32.       System.out.println("程序继续执行");
    33.   }
    34. }

    比较：

向上转型 向下转型
又称隐式转型、自动转型 又称强制类型转换
父类引用指向子类实例，可以调用子类重写父类的方法以及父类派生的方法，无法调用子类独有方法 子类引用指向父类对象，此处必须进行强制转换，可以调用子类特有的方法
小类转为大类 必须满足转型条件才能进行转换

instanceof关键字

在之前的章节中，我们提到向下转型需要满足转型条件，那么我们该如何才能知道是否满足转型条件呢
这时候，instanceof关键字就派上用处了！
6. 多态 - 图3
instanceof关键字用于判断左边的对象是否满足右边的实例。如果满足返回true，否则返回false。

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         //animal的引用  = 具体的animal实例
  4.         Animal one = new Animal();
  5.         Animal two = new Cat();
  6.         Animal three = new Dog();
  8.         one.eat();
  9.         two.eat();
  10.         three.eat();
  12.         one.getMonth();
  13.         two.getName();
  14.         //three.sleep();
  16.         System.out.println("=======================================");
  17.         if(two instanceof Cat) {
  18.             Cat temp = (Cat)two;
  19.             temp.eat();
  20.             temp.run();
  21.             temp.getMonth();
  22.             System.out.println("two可以转换为Cat类型");
  23.         }
  25.         if(two instanceof Dog) {
  26.             Dog temp1 = (Dog)two;
  27.             temp1.eat();
  28.             temp1.sleep();
  29.             temp1.getMonth();
  30.             System.out.println("two可以转换为Dog类型");
  31.         }
  33.         if(two instanceof Animal) {
  34.             System.out.println("Animal");
  35.         }
  37.         if(two instanceof Object) {
  38.             System.out.println("Object");
  39.         }
  41.         //所以two对象具有Animal类型和Object类型的特征
  43.         System.out.println("程序继续执行");
  44.     }
  45. }

类型转换案例

案例

在原有的项目中，增加一个主人类。在猫类中添加玩线球方法

  1. public class Master {
  2.     /**
  3.      * 喂宠物：
  4.      * 喂猫咪：吃完东西后，主人会带着去玩线球
  5.      * 喂狗狗：吃完东西后，主人会带着去睡觉
  6.      * 养兔子、样鹦鹉、养乌龟
  7.      */
  8.     //方案一：编写方法，传入不同类型的动物，调用各自的方法
  9.     public void feed(Cat cat) {
  10.         cat.eat();
  11.         cat.palyBall();
  12.     }
  14.     public void feed(Dog dog) {
  15.         dog.eat();
  16.         dog.sleep();
  17.     }
  19.     //方案二：编写方法传入动物的父类，方法中通过类型转换，调用指定的子类的方法
  20.     public void feed(Animal ani) {
  21.         if(ani instanceof Cat) {
  22.             Cat cat = (Cat)ani;
  23.             cat.eat();
  24.             cat.palyBall();
  25.         } else if(ani instanceof Dog) {
  26.             Dog dog = (Dog)ani;
  27.             dog.eat();
  28.             dog.sleep();
  29.         }
  30.     }
  31. }

多个对象要实现一个方法吃的时候，一般的解决方法是写重载函数。
而新的解决方法是用一个方法传参的时候先向上转化成父类， 然后再根据实际情况进行判断后，转化成原来的类型 ，在调用自己本身的方法 （向下转型）
利用多态，实际参数可以是该形参的类型和其子类类型

新增需求

针对主人空闲时间的判断，如果时间多则养狗，如果时间少则养猫。

  1. package com.dodoke.proJ.animal;
  2. public class Master {
  3.     //方案一
  4.     public Dog hasManyTime() {
  5.         System.out.println("主人空闲时间充足，适合养狗狗");
  6.         return new Dog();
  7.     }
  9.     public Cat hasLittleTime() {
  10.         System.out.println("主人空闲时间比较少，适合养猫咪");
  11.         return new Cat();
  12.     }
  14.     //方案二
  15.     public Animal raise(boolean isManyTime) {
  16.         if(isManyTime) {
  17.             System.out.println("主人空闲时间充足，适合养狗狗");
  18.             return new Dog();
  19.         } else {
  20.             System.out.println("主人空闲时间比较少，适合养猫咪");
  21.             return new Cat();
  22.         }
  23.     }
  24. }

在方法内部实现多态。返回值为子类对象，由父类引用接收。相当于Animal animal=new Cat();向上转型。
当我们在实际开发当中需要同一个操作行为，针对不同的参数， 返回不同的实例对象，完成不同的操作结果的时候，就比较适用于这种多态的操作。类型转换的优势就会充分体现出来了。
在程序设计中存在一种通用性方法设计，这种方法设计可以不限制参数和返回值类型，重点在于使用Object类型作为参数和返回值类型，但会安全性变低

抽象类

在之前的代码中，我们创建了一个动物类。接下来，我们来看看这段代码

  1. Animal pet = new Animal("花花",2);
  2. pet.eat();

针对于这样的代码，编译运行都没有什么问题，但是它在实际的开发中并没有有效的意义。每个动物都应该有具体的吃东西的行为，实例化pet对象没有意义。实际的开发中会指代具体的猫还是狗来完成指代。如上的代码并不符合程序的逻辑。
那么，该如何限制程序员写这些没有意义的代码呢？
我们可以使用abstract关键字来限制类的实例化。

abstract 是不能修饰成员变量的；

抽象类

  1. public abstract class Animal {}
  2. abstract public class Animal {}

抽象数据类型： 在类的定义前加上 abstract 关键字，使得该类成为一个抽象类
抽象类不允许被实例化，但是可以通过向上转型，指向子类实例，调用子类重写父类的方法以及父类派生的方法
public 与 abstract可以互换，但是却不能 与class关键字相互换位。
抽象类利用子类与父类的继承关系，既限制了子类的设计随意性，又避免了父类无意义的实例化。

应用场景：某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法

抽象方法

  1. public abstract class Animal {
  2.     //属性：昵称、年龄
  3.     private String name;
  5.     private int month;
  7.     /**
  8.      * 抽象方法：没有方法体，在子类中必须重写抽象方法，如果子类不重写，则子类只能设置为抽象类
  9.      */
  10.     public abstract void eat();
  12.     public String getName() {
  13.         return name;
  14.     }
  15.     public void setName(String name) {
  16.         this.name = name;
  17.     }
  18.     public int getMonth() {
  19.         return month;
  20.     }
  21.     public void setMonth(int month) {
  22.         this.month = month;
  23.     }
  24.     public Animal(String name, int month) {
  25.         super();
  26.         this.name = name;
  27.         this.month = month;
  28.     }
  30.     public Animal() {
  31.         super();
  32.     }
  34. }

用abstract修饰的，没有方法体（没有大括号和内容）的方法叫做抽象方法
含有抽象方法的类，一定是抽象类。抽象类中不一定有抽象方法。
在抽象类中的成员方法可以包括一般方法和抽象方法。
抽象类不能实例化，即使抽象类中不包含抽象方法，这个抽象类也不能创建实例。
一个类继承抽象类后，必须重写所有的抽象方法，否则也是抽象类，不同的子类对父类的抽象方法可以有不同的实现。

如果方法定义为 static，就不能使用 abstract 修饰符； 如果方法定义为 private ，也不能使用 abstract 修饰符；

抽象类体现的是一种模板模式的设计思想，抽象类作为多个子类的通用模板，子类在抽象的基础上进行扩充，但是子类整体上会保留抽象类的行为方法（必须要实现抽象类的抽象方法）。
抽象类一般只是定义需要使用的方法，把不能实现的部分抽象成抽象方法，留给子类去实现。
父类中可以有实现的方法，但是子类也是可以对已经实现的方法进行改造的（override），但是如果在子类中还需要调用父类的实现方法，可以使用 super 关键字。