面向对象三大特征之一：多态

java中引用变量有两个类型：编译时类型和运行时类型。编译类型由声明该变量使用的类型决定的，运行时类型由实际赋给该变量的对象决定的。

也就是：编译时， 看左边；运行时，看右边

多态

当编译时类型和运行时类型不一样时，就是我们所说的多态。

在多态的情况下，看左边 看的时父类的引用 看右边 看的是子类的对象

1、多态的使用前提

类的继承关系或是接口的实现

方法的重写

2、多态的调用的特征

Animal父类

public class Animal {
     int num = 10;
    public void eat(){
        System.out.println("动物吃食物...");
    }
}

Dog子类

public class Dog extends Animal{
    int num = 20;
    @Override
    public void eat() {
        System.out.println("小狗吃骨头...");
    }
}

 Test类

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
    }
}

 在Test类中

Animal animal = new Dog();

new 一个Dog的实例对象，但是是父类引用，这就是多态。

接下来演示一下在多态情况下调用成员变量和方法的运行情况。

2.1、调用成员变量（编译运行看左边）

在Test类中添加

System.out.println(animal.num);

输出结果

10

 当在多态的情况下，父类和子类都有相同的变量，调用相同的成员变量的时候，打印出来的是父类的成员变量的定义。

2.2、调用成员方法（编译看左边，运行看右边）

在Test类中添加

animal.eat();

输出结果

小狗吃骨头...

当在多态的情况下，子类重写父类的方法，调用方法时，会执行子类中定义的方法。

但要是调用父类中不存在的方法，编译会报错。

在Dog子类中添加一个方法

public class Dog extends Animal{
    int num = 20;
    @Override
    public void eat() {
        System.out.println("小狗吃骨头...");
    }
    public void sleep(){
        System.out.println("小狗在睡觉");
    }
}

Test类中

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.sleep();
    }
}

运行结果

3、对象类型转换

有两种类型：

向上转型：子类对象 ——>父类对象

向下转型：父类对象 ——>子类对象

对于向上转型，程序会自动完成。向下转型时，必须指明转型的子类类型。

 格式

对象向上转型：父类类型 父类对象 = 子类实例;

对象向下转型：（有两个步骤）

父类类型 父类对象 = 子类实例;

子类类型 子类对象 = （子类）父类对象;

对象向上转型 

多态本身是子类向父类向上转换（自动转换）的过程。

Animal animal = new Dog();就是向上转换，这个过程是自动完成的，

其实相当于是Animal animal = （Animal）new Dog(); 

对象向下转型

Animal父类和Dog子类不变。

Test类

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
        Dog dog = (Dog) animal;//向下转型
        dog.eat();
    }
}

运行结果 

小狗吃骨头...

 对象转换类型问题

新建一个Cat类

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("小猫吃鱼");
    }
}

Test类

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
        Cat cat = (Cat) animal;
        cat.eat();
    }
}

 对象向下转型的时候，转型为另一个子类。

运行结果

instanceof 

出现报错，为了避免这个问题，java中提供instanceof关键字判断一个对象是否是某一个类（或接口）的实例。

特征：

如果对象是指定的类的实例对象，则返回true，否则返回false。

Test类

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
        if (animal instanceof Dog){
            Dog dog = (Dog) animal;
            dog.sleep();
        }else if (animal instanceof Cat){
            Cat cat = (Cat) animal;
            cat.sleep();
        }
    }
}

如果animal 是Dog类的实例化对象，那么则向下转型为Dog类对象，否则就向下转型为Cat类对象。