Java 中多态和重载有什么区别-java教程-PHP中文网

多态和重载的核心区别在于它们解决的是不同层面的复用问题：重载是编译时多态，通过方法签名区分同名方法；多态是运行时多态，通过对象实际类型决定调用哪个实现。简单来说，重载发生在同一个类中或父子类之间，编译器在编译阶段就确定了具体调用的方法；而多态发生在继承体系中，程序运行到调用那一刻才根据对象的真实类型动态绑定方法。

Java 中多态和重载有什么区别

重载是如何在编译期确定调用目标的

重载允许在同一个作用域内定义多个同名方法，只要它们的参数列表（参数个数、类型或顺序）不同即可。编译器在处理代码时，会根据你传入的实际参数类型和数量，去匹配最符合的一个方法签名。这个过程完全在编译阶段完成，生成的字节码中直接指向了那个特定的方法地址，不存在任何动态查找的开销。如果找不到匹配的方法，或者存在二义性，编译器会直接报错。

Java 中多态和重载有什么区别

public class OverloadDemo {
    public void print(String s) {
        System.out.println("String: " + s);
    }

    public void print(int i) {
        System.out.println("Int: " + i);
    }

    public static void main(String[] args) {
        OverloadDemo demo = new OverloadDemo();
        demo.print("Hello"); // 调用 print(String)
        demo.print(42);      // 调用 print(int)
    }
}

上述代码展示了重载的基本用法。当调用 demo.print("Hello") 时，编译器看到字符串字面量，自动匹配到接受 String 参数的方法。当调用 demo.print(42) 时，整数字面量匹配到接受 int 参数的方法。这两个调用在编译后的字节码中是两个完全不同的指令，分别指向不同的方法入口。

多态是如何在运行期动态选择实现的

多态依赖于继承和方法重写。当你使用父类引用指向子类对象时，编译器只知道这个引用是父类类型，所以它只允许调用父类中声明的方法。但是，如果子类重写了该方法，JVM 在运行时会根据引用所指向的实际对象类型，去查找并执行子类中覆盖后的版本。这种机制被称为动态方法分派，它使得代码可以针对通用接口编写，而具体的行为由具体的实现类决定。

javascript-typescript-typescript-scaffold

你是 TypeScript 项目架构专家，专注于脚手架搭建生产就绪的 Node.js 和前端应用。生成包含现代工具链（pnpm、Vite、Next.js）、类型

下载

Java 中多态和重载有什么区别

abstract class Animal {
    abstract void makeSound();
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Woof!");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Meow!");
    }
}

public class PolymorphismDemo {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();
        myDog.makeSound(); // 输出 Woof!
        myCat.makeSound(); // 输出 Meow!
    }
}

在上面的例子中，myDog 和 myCat 都是 Animal 类型的引用，但它们指向的对象分别是 Dog 和 Cat。当调用 makeSound() 时，JVM 会检查引用的实际类型。对于 myDog，它发现实际对象是 Dog，于是执行 Dog 类中的 makeSound 方法；对于 myCat，则执行 Cat 类中的方法。这就是为什么相同的代码行能产生不同输出的原因。

当子类没有重写父类方法时多态的表现是什么

如果子类继承了父类但没有重写某个方法，那么即使通过父类引用调用该方法，执行的依然是父类中的原始实现。这是因为动态绑定只针对被重写的方法生效。在这种情况下，多态并没有改变方法的行为逻辑，只是保持了接口的统一性。这种行为模式常用于模板方法设计模式，其中父类定义了算法骨架，而子类可以选择性地重写特定步骤。

class Base {
    void show() {
        System.out.println("Base show");
    }
}

class Derived extends Base {
    // 没有重写 show 方法
}

public class NoOverrideDemo {
    public static void main(String[] args) {
        Base obj = new Derived();
        obj.show(); // 输出 Base show
    }
}

在这个示例中，Derived 类没有提供 show 方法的实现。尽管 obj 引用的是 Derived 实例，但调用 obj.show() 时，由于没有找到重写版本，JVM 回退到父类 Base 的实现。这证明了多态的动态特性仅作用于存在重写关系的方法上。