本文共 3256 字，大约阅读时间需要 10 分钟。

多态（Polymorphism）是Java语言中的一个核心概念，它描述了一个行为可以在不同的对象类型中表现出不同的形式。这种特性让Java程序具有了高度的灵活性和扩展性。以下从多个角度深入探讨多态的实现机制和应用场景。

多态的本质

多态的关键在于行为的多样性。在Java中，当一个引用变量（无论是数组、对象还是集合）指向不同的具体对象时，调用该引用变量的方法会根据目标对象的实际类型决定执行哪个方法。这种行为在编译阶段无法确定，因为编译器只能根据引用变量的声明类型来选择方法，但在运行时，Java的方法调用机制会根据实际对象的类型进行绑定。

多态的实现依赖于三个关键条件：

多态的简单应用

考虑以下程序清单：

// 子类继承父类
public class Wangxiaoer extends Wanger {
    public void write() {
        System.out.println("记住仇恨，表明我们要奋发图强的心智");
    }
    public static void main(String[] args) {
        // 父类引用指向子类对象
        Wanger[] wangers = {
            new Wanger(),
            new Wangxiaoer()
        };
        for (Wanger wanger : wangers) {
            wanger.write();
        }
    }
}
class Wanger {
    public void write() {
        System.out.println("勿忘国耻");
    }
}

在这个程序中，Wanger[] wangers 数组包含两个对象：一个是Wanger类实例，另一个是Wangxiaoer类实例。当循环调用write()方法时，Wanger引用会根据实际对象类型分别调用父类和子类的实现，输出不同的结果。

多态与后期绑定

多态的实现依赖于后期绑定机制。编译器在编译阶段无法确定引用变量 ultimately bound 到哪个具体类中，因为引用变量可能在运行时指向不同的对象类型。例如，在程序清单1-1中：

Wanger[] wangers = { new Wanger(), new Wangxiaoer() };
for (Wanger wanger : wangers) {
    wanger.write();
}

编译器只知道Wanger引用变量的类型，因此在编译阶段无法知道write()方法 ultimately 会调用哪个类的实现。在运行时，Java的方法调用机制会根据当前对象的类型找到正确的方法体进行调用。

这种特性使得多态成为一个非常灵活的机制，可以通过动态绑定允许程序在运行时根据需要选择不同的行为实现。

多态与构造器

构造器（constructor）的多态性质可能会带来一些意想不到的结果。例如：

public class Wangxiaosan extends Wangsan {
    private int age = 3;
    public Wangxiaosan(int age) {
        this.age = age;
        System.out.println("王小三的年龄：" + this.age);
    }
    public void write() {
        System.out.println("我小三上幼儿园的年龄是：" + this.age);
    }
    public static void main(String[] args) {
        new Wangxiaosan(4); // 上幼儿园之前
        // 我小三上幼儿园的年龄是：0
        // 上幼儿园之后
        // 王小三的年龄：4
    }
}
class Wangsan {
    Wangsan() {
        System.out.println("上幼儿园之前");
        write();
        System.out.println("上幼儿园之后");
    }
    public void write() {
        System.out.println("老子上幼儿园的年龄是3岁半");
    }
}

在上述程序中，当创建Wangxiaosan对象时，首先会调用Wangsan类的构造器。由于Wangsan类的构造器中调用了write()方法，而Wangxiaosan类覆盖了write()方法，结果会输出Wangsan类的write()方法。只有在子类构造器被调用之后，Wangxiaosan类的write()方法才会被执行。

多态与向下转型

向下转型（type casting）是多态的一种应用，但也伴随着潜在的风险。向下转型意味着将父类引用强制转换为子类类型。例如：

public class Wangxiaosi extends Wangsi {
    public void write() {
        System.out.println("记住仇恨，表明我们要奋发图强的心智");
    }
    public void eat() {
        System.out.println("我不喜欢读书，我就喜欢吃");
    }
    public static void main(String[] args) {
        Wangsi[] wangsis = {
            new Wangsi(),
            new Wangxiaosi()
        };
        // wangsis[1] 能够向下转型
        ((Wangxiaosi) wangsis[1]).write();
        // wangsis[0] 不能向下转型
        ((Wangxiaosi)wangsis[0]).write();
    }
}
class Wangsi {
    public void write() {
        System.out.println("勿忘国耻");
    }
    public void read() {
        System.out.println("每周读一本好书");
    }
}

在上述程序中，wangsis[1]是Wangxiaosi对象，可以安全地向下转型为Wangxiaosi类型并调用write()方法。然而，wangsis[0]是Wangsi对象，向下转型会导致ClassCastException，因为Wangsi对象没有eat()方法。

总结

多态是Java语言的核心特性之一，它允许程序在运行时根据对象的具体类型选择适当的方法进行调用。通过多态，开发者可以在不修改源代码的情况下扩展程序的功能，使程序具有更强的灵活性和可维护性。

多态的实现依赖于以下关键点：

多态的应用场景广泛，包括方法调用、构造器调用、向下转型等。理解多态的原理对于Java程序的开发和优化至关重要。