我们经常说“哺乳动物有很多种叫声”，例如，“吼”“嚎”“汪汪”“喵喵”等，这就是叫声的多态。
当一个类有很多子类时，并且这些子类都重写了父类中的某个方法，那么当把子类创建的对象的引用放到一个父类的对象中时，就得到了该对象的一一个上转型对象，那么这个上转型对象在调用这个方法时就可能具有多种形态，因为不同的子类在重写父类的方法时可能产生不同的行为，例如，狗类的上转型对象调用“叫声”方法时产生的行为是“汪汪”，而猫类的，上转型对象调用“叫声”方法时，产生的行为是‘喵喵”，等等。
多态性就是指父类的某个方法被其子类重写时，可以各自产生自己的功能行为。
多态：同一个事物，作用条件不一样，结果不一样 多态：同一个父类引用，指向不同的子类实例，执行不同的操作 方法重写是实现多态的前提
多态实现步骤： 1）在抽象父类中定义抽象方法 2）子类继承抽象父类并重写父类中所有的抽象方法 3）测试类中创建父类引用指向不同的子类实例，父类引用调用方法，调用的是子类重写后的那些方法 向上转型（自动类型转换）：父类的引用指向子类的实例 向下转型（强制类型转换）：子类的引用指向父类的引用 父类的引用无法调用子类里独有的方法，必须使用向下转型成对应的子类，才能通过子类去调用子类中独有的方法 在向下转型的时候，容易出现ClassCastException（类型转换异常），原因是将父类引用转换成了不匹配的子类对象
= ( );
可以通过instanceof关键字类判断父类引用指向的是哪一个子类实例，从而避免类型转换异常
抽象类和抽象方法抽象方法：使用abstract修饰的方法为抽象方法 1）抽象方法没有方法体 2）抽象方法所在的类需要声明为抽象类 3）子类继承一个抽象类后，子类中必须重写抽象父类中所有的抽象方法，如果不重写，那么子类也需要定义为抽象类 抽象类：使用abstract修饰的类为抽象类 1）抽象类的声明跟之前声明一个类没有太大的区别，依然可以封装属性、声明构造方法、声明getXxx()/setXxx()方法、重写toString()方法等 2）抽象类中可以包含抽象方法、也可以不包含抽象方法（但是抽象方法所在的类一定要声明为抽象类） 3）抽象类不能实例化（不能通过new的方式来创建对象）
案例：
父类
package cn.bdqn.demo06;
public abstract class Father {//定义抽象类
private String name;
private int age;
public Father() {
super();
}
public Father(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Father [name=" + name + ", age=" + age + "]";
}
public abstract void test();//抽象方法
}
子类：
package cn.bdqn.demo06;
public class Son1 extends Father {
private double height;
public Son1() {
super();
}
public Son1(String name, int age, double height) {
super(name, age);
this.height = height;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
@Override
public void test() {
System.out.println("我是Son1类中从写Father类里的test()方法");
}
//定义一个Son1类里独有的方法
public void son1Method(){
System.out.println("我是Son1类里的独有方法son1Method()");
}
}
package cn.bdqn.demo06;
public class Son2 extends Father {
private double weight;
public Son2() {
super();
}
public Son2(String name, int age, double weight) {
super(name, age);
this.weight = weight;
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
@Override
public void test() {
System.out.println("我是Son2类中从写Father类里的test()方法");
}
//定义一个Son2类中独有的方法
public void son2Method(){
System.out.println("我是Son2类中独有的son2Method()方法");
}
}
测试类
package cn.bdqn.demo06;
public class Test {
public static void main(String[] args) {
// 创建Father类对象
// Father father = new Father();//抽象类不能实例化，因为没有意义
//类名 对象名= new 子类类名();
//向上转型：父类引用指向子类的实例
Father father = new Son1("张三", 22, 173);
father.test();
/*
* 父类的引用指向子类的实例，通过父类引用去调用方法的时候，
* 如果子类重写了父类引用调用的那个方法，那么父类引用调用的是子类重写后的那个方法
* 如果父类引用调用的那个方法在子类中没有被重写，那么父类引用调用的就是父类里的那个方法
*/
// father = new Son2("李四", 25, 160);
// father.test();
//父类的引用不能调用子类里的方法，需要进行强制类型转换(向下转型)
// father.son1Method();
//instanceof运算符的使用
if(father instanceof Son1){
//向下转型：子类的引用指向父类的引用
Son1 son = (Son1)father;
son.son1Method();
}else if(father instanceof Son2){
//向下转型：子类的引用指向父类的引用
Son2 son = (Son2)father;
son.son2Method();
}
}
}
