多态
可以理解为一个事物的多种形态,也就是说一个子类对象既可以给子类成员赋值，也可以给父类的成员赋值。
多态的最终体现为父类的引用变量指向子类对象。
多态的前提是必须有子父类关系或者是实现接口的关系，否二无法完成多态。
在创建多态的父类引用变量调用方法时，运行的是子类重写后的方法。Person p = new Student();p.show();该方法调用的是子类重写后的方法
多态的定义格式
定义多态对象的格式：
类的定义：父类类型 对象名 = new 子类对象();
对象名.方法();//调用后必须是子类重写后的方法
抽象类的定义：抽象类父类类型 对象名 = new 子类对象();
对象名.方法();//调用后必须是子类重写后的方法
接口的定义格式：接口类型 对象名 = new 实现类对象();
对象名.方法();//调用后必须是子类重写后的方法
多态中成员的特点
多态中成员变量的特点：
编译时，看父类中有没有这个变量，如果有，编译成功，没有，编译失败
运行时，运行的是父类中的变量
简言之，编译运行都父类
多态中成员方法的特点：
编译时，看父类中有没有这个方法，如果有，编译成功，没有，编译失败
运行时，运行的是子类中重写后的方法。
简言之，编译看走边，运行看右边
instanceof关键字
该关键字的作用：用于引用数据类型的比较判断，创建一个多态对象，比较这个对象是不是子类对象，比如：Person p = new Student();判断这个p是不是Student对象，如果是，返回true，不是返回false，格式如下：
//创建子类的多态对象
Person p = new Student();
//判断这个P是不是Student类
boolean b = p instanceof Student;
结果返回的是true
boolean b = p instanceof Teacher;
运行返回的是false
多态的转型
多态和基本数据类型一样，都需要数据的转型，但稍有区别。
向上转型（自动提升）：这种情况不需要我们自己操作，它会自动进行转型，比如
Person p = new Student();
p.sleep();
他会自动转型，这种的缺点在于，只能调用他们的公共方法，子类特有的方法不能调用，这时就需要对该类型进行向下转型
向下转型（强制转换）：
Person p = new Student();
Student s = (Student)p;
s.study();
这样就可以调用子类特有的学习方法了。
多态转型的案例
l 动物类
package cn.itcast.duotai;
/*
* 定义一个抽象的动物类
* 定义一个抽象的吃的方法
*/
public abstract class Animal {
//定义一个抽象的吃的方法
public abstract void eat();
}l 猫类
package cn.itcast.duotai;
/*
* 定义猫的类继承动物类
* 重写父类吃的方法
* 定义猫特有的方法
*/
public class Cat extends Animal{
//重写父类吃的方法
public void eat(){
System.out.println("猫吃猫粮");
}
//定义猫特有的方法
public void catchMice(){
System.out.println("猫会抓老鼠");
}
}l 狗类
package cn.itcast.duotai;
/*
* 定义狗的类继承动物类
* 重写动物类吃的方法
* 定义狗特有的方法
*/
public class Dog extends Animal{
//重写动物类吃的方法
public void eat(){
System.out.println("狗吃狗粮");
}
//定义狗特有的方法
public void lookHome(){
System.out.println("狗会看家");
}
}l 测试类
package cn.itcast.duotai;
/*
* 测试类
* 创建猫，狗的多态对象，调用他们特有的方法
* 将对象进行强制转换，调用猫，狗特有的方法
*/
public class Test {
public static void main(String[] args) {
//创建猫，狗的多态对象，调用他们特有的方法
Animal a1 = new Cat();
Animal a2 = new Dog();
a1.eat();
a2.eat();
//将对象进行强制转换，调用猫，狗特有的方法
Cat c = (Cat)a1;
c.catchMice();
Dog d = (Dog)a2;
d.lookHome();
}
}案例
电脑的功能是开机，关机功能，它有USB接口，可以接入许多的外接设备，比如键盘，鼠标，将这个事物在代码中体现出来：
l 电脑类
package cn.itcast.computerDemo;
/*
* 定义电脑类
* 功能：打开电脑，关闭电脑，调用USB的功能
*/
public class Computer {
//打开电脑
public void openComputer(){
System.out.println("开启电脑");
}
//关闭电脑
public void closeComputer(){
System.out.println("关闭电脑");
}
//调用USB的功能
public void useUSB(USB usb){
usb.open();
usb.close();
}
}l USB接口类
package cn.itcast.computerDemo;
/*
* 定义usb接口
* 抽象概念，打开，关闭
*/
public interface USB {
public abstract void open();
public abstract void close();
}l 鼠标类
package cn.itcast.computerDemo;
/*
* 定义鼠标类实现接口
* 重写接口功能
*/
public class Mouse implements USB{
public void open(){
System.out.println("打开鼠标");
}
public void close(){
System.out.println("关闭鼠标");
}
}l 键盘类
package cn.itcast.computerDemo;
/*
* 定义键盘类实现接口类
* 重写接口中的方法
*/
public class keyBoard implements USB{
//重写接口中的方法
public void open(){
System.out.println("打开键盘");
}
public void close(){
System.out.println("关闭键盘");
}
}l 测试类
package cn.itcast.computerDemo;
/*
* 测试类
*/
public class Test {
public static void main(String[] args) {
//创建电脑的对象
Computer c = new Computer();
c.openComputer();
//调用鼠标的功能
c.useUSB(new Mouse());
//调用键盘的功能
c.useUSB(new keyBoard());
c.closeComputer();
}
}