Skip to content
The Chat Archive
Metallama-4-maverick-17b-128e-instruct· Meta LMArena Human Preference 140K

根据以下知识点给出实操题: 1.6 多态的实现机制 多态是面向对象程序设计中代码重用的一个重要机制,它表示当同一个操作作用在不同的对象…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.5-flash’s answer.
  1. User

    根据以下知识点给出实操题: 1.6 多态的实现机制 多态是面向对象程序设计中代码重用的一个重要机制,它表示当同一个操作作用在不同的对象 的时候,会出现不同的语义,从而会产生不同的结果。比如:同样是“+”操作, 3+4 用来实现整数相 加,而“3”+“4”却实现了字符串的连接。在 Java 语言中,多态主要有以下两种表现方式: (1)重载(Overload) 重载是指同一个类中有多个同名的方法,但这些方法有着不同的参数,因此可以在编译的时候 就确定到底调用哪个方法,它是一种编译时多态。重载可以被看作一个类中的方法多态性。 (2)重写(Override) 子类可以重写父类的方法,因此同样的方法会在父类与子类中有着不同的表现形式。在 Java 语 言中,基类的引用变量不仅可以指向基类的实例对象,也可以指向其子类的实例对象。同样,接口 的引用变量也可以指向其实现类的实例对象。而程序调用的方法在运行期才动态绑定(绑定指的是 将一个方法调用和一个方法主体连接到一起),就是引用变量所指向的具体实例对象的方法,也就 是内存里正在运行的那个对象的方法,而不是引用变量的类型中定义的方法。通过这种动态绑定的 方法实现了多态。由于只有在运行时才能确定调用哪个方法,因此通过方法重写实现的多态也可以 被称为运行时多态。如下例所示: class Base { public Base() { g(); } public void f() { System.out.println("Base f()"); } public void g() { System.out.println("Base g()"); } } class Derived extends Base { public void f() { System.out.println("Derived f()"); } public void g() { System.out.println("Derived g()"); } } public class Test { public static void main(String[] args) { Base b=new Derived();14 Java 程序员面试笔试宝典 第 2 版 b.f(); b.g(); } } 程序的输出结果为: Derived g() Derived f() Derived g() 上例中,由于子类 Derived 的 f()方法和 g()方法与父类 Base 的方法同名,因此 Derived 的方法 会覆盖 Base 的方法。在执行 Base b = new Derived()语句的时候,会调用 Base 类的构造函数,而在 Base 的构造函数中,执行了 g()方法,由于 Java 语言的多态特性,此时会调用子类 Derived 的 g()方 法,而非父类 Base 的 g()方法,因此会输出 Derived g()。由于实际创建的是 Derived 类的对象,后面 的方法调用都会调用子类 Derived 的方法。 此外,只有类中的方法才有多态的概念,类中成员变量没有多态的概念。如下例所示: class Base { public int i=1; } class Derived extends Base { public int i=2; } public class Test { public static void main(String[] args) { Base b=new Derived(); System.out.println(b.i); } } 程序输出结果为: 1 由此可见,成员变量是无法实现多态的,成员变量的值取父类还是子类并不取决于创建对象的 类型,而是取决于定义的变量的类型,这是在编译期间确定的。在上例中,由于 b 所属的类型为 Base, b.i 指的是 Base 类中定义的 i,所以程序输出结果为 1。

  2. Assistant

    实操题:多态的实现机制

    题目1:重载(Overload)示例

    请编写一个Java类,包含多个同名方法,但这些方法有不同的参数列表,演示方法重载。

    public class Calculator {
        // 在这里添加代码,实现方法重载
        public int add(int a, int b) {
            return a + b;
        }
    
        public double add(double a, double b) {
            return a + b;
        }
    
        public int add(int a, int b, int c) {
            return a + b + c;
        }
    
        public static void main(String[] args) {
            Calculator calculator = new Calculator();
            System.out.println(calculator.add(1, 2)); // 输出:3
            System.out.println(calculator.add(1.5, 2.5)); // 输出:4.0
            System.out.println(calculator.add(1, 2, 3)); // 输出:6
        }
    }
    

    题目2:重写(Override)示例

    请创建一个父类Animal和一个子类Dog,Dog继承自Animal。在Animal类中定义一个方法sound(),并在Dog类中重写该方法。演示运行时多态。

    class Animal {
        // 在这里添加代码
        public void sound() {
            System.out.println("Animal makes a sound");
        }
    }
    
    class Dog extends Animal {
        // 在这里添加代码,重写sound()方法
        @Override
        public void sound() {
            System.out.println("Dog barks");
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            Animal animal = new Dog();
            animal.sound(); // 输出:Dog barks
        }
    }
    

    题目3:成员变量与多态

    请创建一个父类Base和一个子类Derived,在两个类中分别定义一个同名的成员变量i。然后在Test类中演示成员变量无法实现多态。

    class Base {
        // 在这里添加代码
        public int i = 1;
    }
    
    class Derived extends Base {
        // 在这里添加代码
        public int i = 2;
    }
    
    public class Test {
        public static void main(String[] args) {
            Base b = new Derived();
            System.out.println(b.i); // 输出:1
            // 如果要访问子类Derived的i,需要强制类型转换
            System.out.println(((Derived) b).i); // 输出:2
        }
    }
    

    题目4:构造函数与多态

    请创建一个父类Base和一个子类Derived,在Base的构造函数中调用一个被Derived重写的方法,观察输出结果。

    class Base {
        // 在这里添加代码
        public Base() {
            g();
        }
    
        public void g() {
            System.out.println("Base g()");
        }
    }
    
    class Derived extends Base {
        // 在这里添加代码,重写g()方法
        @Override
        public void g() {
            System.out.println("Derived g()");
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            Base b = new Derived(); // 输出:Derived g()
        }
    }
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.