多态
多态是继封装、继承之后，面向对象的第三大特性。 生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也 是不一样的。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态。 定义 多态： 是指同一行为，具有多个不同表现形式。
-
继承或者实现【二选一】
-
方法的重写【意义体现：不重写，无意义】
-
父类引用指向子类对象【格式体现】
1.2 多态的体现
父类类型 变量名 = new 子类对象；
变量名.方法名();
父类类型：指子类对象继承的父类类型，或者实现的父接口类型。
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写 后方法。
public class Demo01Multi {
public static void main(String[] args) {
// 使用多态的写法
// 左侧父类的引用，指向了右侧子类的对象
Fu obj = new Zi();
obj.method();
obj.methodFu();
}
}
父类
package cn.itcast.day10.demo04;
public class Fu {
public void method() {
System.out.println("父类方法");
}
public void methodFu() {
System.out.println("父类特有方法");
}
}
子类
package cn.itcast.day10.demo04;
public class Zi extends Fu {
@Override
public void method() {
System.out.println("子类方法");
}
}
多态中成员变量的使用特点
访问成员变量的两种方式：
-
直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找。
-
间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找。
main类
package cn.itcast.day10.demo05;
public class Demo01MultiField {
public static void main(String[] args) {
// 使用多态的写法，父类引用指向子类对象
Fu obj = new Zi();
System.out.println(obj.num); // 父：10
// System.out.println(obj.age); // 错误写法！
System.out.println("=============");
// 子类没有覆盖重写，就是父：10
// 子类如果覆盖重写，就是子：20
obj.showNum();
}
}
父类
package cn.itcast.day10.demo05;
public class Fu /*extends Object*/ {
int num = 10;
public void showNum() {
System.out.println(num);
}
public void method() {
System.out.println("父类方法");
}
public void methodFu() {
System.out.println("父类特有方法");
}
}
子类
package cn.itcast.day10.demo05;
public class Zi extends Fu {
int num = 20;
int age = 16;
@Override
public void showNum() {
System.out.println(num);
}
@Override
public void method() {
System.out.println("子类方法");
}
public void methodZi() {
System.out.println("子类特有方法");
}
}
多态中成员变量的使用方法
在多态的代码当中，成员方法的访问规则是： 看new的是谁，就优先用谁，没有则向上找。
口诀：编译看左边，运行看右边。
对比一下： 成员变量：编译看左边，运行还看左边。 成员方法：编译看左边，运行看右边。
package cn.itcast.day10.demo05;
public class Demo02MultiMethod {
public static void main(String[] args) {
Fu obj = new Zi(); // 多态
obj.method(); // 父子都有，优先用子
obj.methodFu(); // 子类没有，父类有，向上找到父类
// 编译看左边，左边是Fu，Fu当中没有methodZi方法，所以编译报错。
// obj.methodZi(); // 错误写法！
}
}
多态的好处
实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展 性与便利。代码如下：
父类
public abstract class Animal {
public abstract void eat();
}
定义子类：
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
} }
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
} }
测试类
public class Test { public static void main(String[] args) { // 多态形式，创建对象 Cat c = new Cat(); Dog d = new Dog(); // 调用showCatEat showCatEat(c); // 调用showDogEat
showDogEat(d); /* 以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代 而执行效果一致 */ showAnimalEat(c);
showAnimalEat(d); }
public static void showCatEat (Cat c){
c.eat(); }
public static void showDogEat (Dog d){
d.eat(); }
public static void showAnimalEat (Animal a){
a.eat(); } }
由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当 然可以把Cat对象和Dog对象，传递给方法。 当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致， 所以showAnimalEat完全可以替代以上两方法。 不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用 showAnimalEat都可以完成。 所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。
向上转型/向下转型
向上转型
多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。 当父类引用指向一个子类对象时，便是向上转型。
使用格式：
父类类型 变量名 = new 子类类型（）；
如 animal a = new cat();
向上转型一定是安全的，没有问题的，正确的。但是也有一个弊端： 对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。
解决方案：用对象的向下转型【还原】。
向下转型
父类类型向子类类型向下转换的过程，这个过程是强制的。
子类类型 变量名 = （子类类型）父类变量名
如 dog c = (dog) a
为什么要转型
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥 有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子 类特有的方法，必须做向下转型。
定义测试类：
package cn.itcast.day10.demo06;
public class Demo01Main {
public static void main(String[] args) {
// 对象的向上转型，就是：父类引用指向之类对象。
Animal animal = new Cat(); // 本来创建的时候是一只猫
animal.eat(); // 猫吃鱼
// animal.catchMouse(); // 错误写法！
// 向下转型，进行“还原”动作
Cat cat = (Cat) animal;
cat.catchMouse(); // 猫抓老鼠
// 下面是错误的向下转型
// 本来new的时候是一只猫，现在非要当做狗
// 错误写法！编译不会报错，但是运行会出现异常：
// java.lang.ClassCastException，类转换异常
Dog dog = (Dog) animal;
}
}
父类
package cn.itcast.day10.demo06;
public abstract class Animal {
public abstract void eat();
}
子类 猫
package cn.itcast.day10.demo06;
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
// 子类特有方法
public void catchMouse() {
System.out.println("猫抓老鼠");
}
}
子类 狗
package cn.itcast.day10.demo06;
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃SHIT");
}
public void watchHouse() {
System.out.println("狗看家");
}
}
转型异常
这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了 Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。 为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下
变量名 instanceof 数据类型 如果变量属于该数据类型，返回true 如果变量不属于该数据类型，返回false
package cn.itcast.day10.demo06;
public class Demo02Instanceof {
public static void main(String[] args) {
Animal animal = new Dog(); // 本来是一只狗
animal.eat(); // 狗吃SHIT
// 如果希望掉用子类特有方法，需要向下转型
// 判断一下父类引用animal本来是不是Dog
if (animal instanceof Dog) {
Dog dog = (Dog) animal;
dog.watchHouse();
}
// 判断一下animal本来是不是Cat
if (animal instanceof Cat) {
Cat cat = (Cat) animal;
cat.catchMouse();
}
giveMeAPet(new Dog());
}
public static void giveMeAPet(Animal animal) {
if (animal instanceof Dog) {
Dog dog = (Dog) animal;
dog.watchHouse();
}
if (animal instanceof Cat) {
Cat cat = (Cat) animal;
cat.catchMouse();
}
}
}
接口多态的综合案例
分析
笔记本电脑（laptop）通常具备使用USB设备的功能。在生产时，笔记本都预留了可以插入USB设备的USB接口， 但具体是什么USB设备，笔记本厂商并不关心，只要符合USB规格的设备都可以。
定义USB接口，具备基本的开启功能和关闭功能。鼠标和键盘要想能在电脑上使用，那么鼠标和键盘也必须遵守 USB规范，实现USB接口，否则鼠标和键盘的生产出来也无法使用
进行描述笔记本类，实现笔记本使用USB鼠标、USB键盘
USB接口，包含开启功能、关闭功能
笔记本类，包含运行功能、关机功能、使用USB设备功能
鼠标类，要实现USB接口，并具备点击的方法
键盘类，要实现USB接口，具备敲击的方法
