Java三大特性有封装、继承、多态。

前面我们已经学过了封装和继承，今天学习多态，如需前面内容的可自行查看。

1、多态的引入

多态是继封装、继承之后，面向对象的第三大特性

生活中，比如交通工具的种类可以分为飞机、汽车、轮船

再比如交通工具的运行方式飞机运行方式是飞在天上、汽车是在马路上开、轮船是在海上行驶

可见，同一行为，通过不同的事物，可以体现出来的不同的形态

多态，描述的就是这样的状态。

2、多态性的概念

2.1 多态的含义

多态性是面向对象的三大特征之一，同一行为，通过不同的事物，可以体现出来的不同的形态。

2.2 Java中多态的具体体现

• 方法重载（在同一个类中，同名的方法，由于形参的不同，实现方法的重载，在调用方法时，可根据实参的组合来选择所调用的方法）
• 方法覆盖（主要在继承时用到，子类继承父类，可以重写父类的非静态的方法）
• 多态参数（新内容，重点、难点，本章主要讲）

2.3 多态的前提

1. 存在继承或者实现关系
2. 子类或实现类必须重写父类方法
3. 父类引用指向子类对象

2.4 父类引用指向子类对象

提个概念，编译器类型指的是‘=’左边的类型，运行期类型指的是‘=’右边的类型。

当有继承关系时，可能发生编译期类型和运行期类型不同的情况，即编译期类型是父类类型，运行期类型是子类类型。

即：父类引用指向子类对象

例如：

//动物类

public class Animal {
    private String name;
    
    public Animal() {
        // TODO Auto-generated constructor stub
        this.name = "动物";
    }
    public void eat() { 
        System.out.println("动物在吃");
    }
    
    static void look() {
        System.out.println("动物在看");
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }   
}

//狗类

public class Dog extends Animal {
    private String name;
    
    public Dog() {
        // TODO Auto-generated constructor stub
        this.name = "狗";
    }
    public void eat() {
        System.out.println("狗在吃");
    }
    
    public void bite() {
        System.out.println("狗咬人");
    }
    
    static void look() {
        System.out.println("狗在看");
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

//测试类：

public class Demo {

    public static void main(String[] args) {
        // 父类对象指向子类引用
        Animal animal = new Dog();

        // 如果子类中重写了父类的方法，按照子类重写的方法执行
        animal.eat();

        // 子类自己扩展的方法，不能调用
//      animal.bite();

        // 调用父类和子类同名的静态方法，调用的是父类的静态方法
        animal.look();

    }
}

3、多态参数

3.1 形参具有多态性

接着上述的案例，如果我们有个方法需要分别调用他们同名的方法，应该怎么做呢？

比如：在Demo类中有个doing（）方法，我想要传进来的对象，让他们都执行他们的eat（）这个方法，此时，我们就需要利用方法参数多态性。

我们只需要把形参的类型定义成父类的类型，我们可以利用上面提到过的验证（当父类引用调用子类对象时，调用重写的方法，是执行子类的重写后方法）。

在一个方法的形参类型你设成父类类型，你传入一个实参对象，如果是一个子类的对象就相当于上述的父类引用调用子类对象，如果传入的是父类对象那就是正常的编译器类型等于运行期类型情况，正常调用。

如此，我们就实现了形参的多态性，在很大程度上减少了代码的重复性，也提高了代码的扩展性。

class Demo{
void doing(Animal a){
a.eat();
}
}

3.2 多态环境下对象造型

上述情况，只是描述对于一些子类重写父类方法的调用，在第一个案例中，我们知道父类引用指向子类对象时，没有办法调用子类扩展的方法，那我们应该怎么做了？

此时，我们就需要用到我们在学习数据类型时的一个概念，强制转换，将父类引用强制转换成子类的类型。

注意：强制转换，只能是将父类类型转换成运行期类型，不能是别的类型。

不仅父类引用可以强制转换成子类的类型，子类的引用也可以强制转换成父类的类型。

从造型方向上看，可分为：

（1）向上造型 –又称自动类型提升

    即父类引用指向子类对象，将子类对象向上造型成为父类类型。

    作用是：提高程序的扩展性。

（2）向下造型 –又称向下转型

   即将子类对象强制转换成父类类型

   作用：实现子类扩展方法的调用。

例如：接着上述例子

//父类引用指向子类对象
Animal animal=new Dog();    
Dog dog = (Dog)animal;      //将父类引用强制转换成子类的类型
dog.look();     //此时调用的子类的静态方法
dog.bite();     //可以调用子类扩展的方法

//子类引用指向子类对象
Dog dog1 = new Dog();
Animal a = (Animal)dog1;   //将子类引用转换成父类类型
a.eat();           //调用的是子类的方法
a.look();          //调用的是父类的静态方法
//a.bite();          //子类扩展的方法不能调用

4、instanceof ()方法

4.1 instanceof 操作符

使用instanceof操作符来判断一个对象的运行期类型，即用来在运行时指出对象是否是特定类的一个实例。

4.1 instanceof 用法

语法：

对象名称 instanceof 类型；

返回值类型：布尔类型

Dog dog1 = new Dog();
Animal a = (Animal)dog1;
System.out.println(a instanceof Animal);

//结果：
true