一篇文章带你了解Java基础-多态

前言

多态是Java中一个比较重要的概念，也是Java语言中的一种基本特征。掌握好多态，可以写出更加优雅、灵活、可扩展的代码。本文将从多态的概念入手，介绍Java中的多态，帮助大家更好地学习和使用Java语言。

什么是多态

多态是指同一对象在不同情况下有不同的表现形式，即同一种行为具有不同的表现形式和状态。在Java语言中，多态分为编译时多态和运行时多态两种。

编译时多态

编译时多态是指在编译阶段，Java编译器将方法调用与方法实现的绑定称为静态绑定。Java中的方法重载就是一种典型的编译时多态。编译时多态是基于类的多态。

例如，我们有一个Animal类，其中包含一个eat()方法和一个sleep()方法：

public class Animal {
    public void eat() {
        System.out.println("Animal eat");
    }
    public void sleep() {
        System.out.println("Animal sleep");
    }
}

我们在Animal类中定义了eat()和sleep()方法，下面我们再定义一个Cat类和一个Dog类，分别继承自Animal类：

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

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog eat");
    }
}

在main函数中，我们可以定义一个Animal类型的对象animal，在运行时动态地创建一个Cat或者Dog的对象，并且将该Cat或者Dog对象赋值给animal对象，例如：

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

我们通过运行这段代码，可以看到结果：

Cat eat
Animal sleep
Dog eat
Animal sleep

这就是编译时多态的一个典型应用，因为在编译阶段，Animal类型的变量animal可能是Cat类型的对象，也可能是Dog类型的对象，所以在调用eat方法时，实际上是根据animal对象的运行时类型来确定调用哪个子类的重写方法。而在调用sleep方法时，由于sleep方法没有被Cat类和Dog类重写，因此调用的是Animal类的原始方法。

运行时多态

运行时多态是指在程序运行时，Java虚拟机将方法调用与方法实现的绑定称为动态绑定。Java中的方法重写就是一种典型的运行时多态。运行时多态是基于对象的多态。

例如，下面我们定义一个Shape抽象类，其中包含一个draw()方法：

public abstract class Shape {
    public abstract void draw();
}

我们再定义一个Circle类和一个Rectangle类，分别继承自Shape类：

public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Circle draw");
    }
}

public class Rectangle extends Shape {
    @Override
    public void draw() {
        System.out.println("Rectangle draw");
    }
}

在main函数中，我们可以定义一个Shape类型的数组shapes，在运行时动态地创建一个Circle对象和一个Rectangle对象，并且将这些对象存入shapes数组中，例如：

public static void main(String[] args) {
    Shape[] shapes = new Shape[2];
    shapes[0] = new Circle();
    shapes[1] = new Rectangle();
    for (Shape shape : shapes) {
        shape.draw();
    }
}

我们通过运行这段代码，可以看到结果：

Circle draw
Rectangle draw

这就是运行时多态的一个典型应用，因为在运行时，shapes数组中存储的元素可能是Circle类型的对象或者Rectangle类型的对象，所以在调用draw方法时，实际上是根据shapes数组中每个元素的运行时类型来确定调用哪个子类的重写方法。

总结

综上所述，多态是Java中的一种基本特征，分为编译时多态和运行时多态两种。编译时多态是基于类的多态，是指在编译阶段，Java编译器将方法调用与方法实现的绑定称为静态绑定；运行时多态是基于对象的多态，是指在程序运行时，Java虚拟机将方法调用与方法实现的绑定称为动态绑定。通过多态，我们可以写出更加优雅、灵活、可扩展的代码。

参考

• Java多态详解 - 阮一峰的网络日志
• Java多态 - 菜鸟教程

示例说明

示例一

在编译时多态的示例中，我们定义了一个Animal类和一个Cat类，其中Cat类继承自Animal类，在Cat类中重写了eat方法。我们在main函数中，先将一个Cat对象赋值给一个Animal类型的变量，然后调用该变量的eat和sleep方法，最后将一个Dog对象赋值给该变量，再次调用eat和sleep方法。

这个例子说明了编译时多态的实现原理，即在编译阶段，Java编译器将方法调用与方法实现的绑定称为静态绑定，而在运行时，根据对象的实际类型确定调用哪个方法。

示例二

在运行时多态的示例中，我们定义了一个Shape抽象类和一个Circle类和一个Rectangle类，其中Circle类和Rectangle类都继承自Shape类，在Circle类和Rectangle类中重写了draw方法。然后我们在main函数中，定义一个Shape类型的数组，将一个Circle对象和一个Rectangle对象存入该数组中，并且使用for循环依次调用这些对象的draw方法。

这个例子说明了运行时多态的实现原理，即在运行时，Java虚拟机将方法调用与方法实现的绑定称为动态绑定，而根据对象的实际类型确定调用哪个方法。通过使用运行时多态，我们可以编写出更加灵活、可扩展的代码。