Skip to content
The Chat Archive
gemini-2.5-flash· Google LMArena Human Preference 140K

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

  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

    好的,根据您提供的关于 Java 多态性(重载、重写、构造器中的多态行为、成员变量非多态性)的知识点,我为您设计了以下实操题目。这些题目旨在帮助学习者巩固和应用所学知识。


    Java 多态性实操题

    总览: 本系列题目将考察您对 Java 中多态性核心概念的理解与应用,包括编译时多态(重载)和运行时多态(重写),以及一些特殊情况(构造器中的方法调用、成员变量的访问)。


    题目一:理解重载(Overload)

    目标: 演示如何在同一个类中创建重载方法,并理解其编译时多态的特性。

    任务:

    1. 创建一个名为 Calculator 的 Java 类。
    2. 在 Calculator 类中,定义以下三个名为 add 的方法:
      • 一个 add 方法接受两个 int 类型参数,返回它们的和。
      • 一个 add 方法接受三个 int 类型参数,返回它们的和。
      • 一个 add 方法接受两个 double 类型参数,返回它们的和。
    3. 在 main 方法中,创建 Calculator 对象,并分别调用这三个 add 方法,打印结果。

    示例代码结构(仅供参考,请自行填充):

    class Calculator {
        // 任务1:定义重载的 add 方法
        // public int add(...)
        // public int add(...)
        // public double add(...)
    }
    
    public class TestCalculator {
        public static void main(String[] args) {
            // 任务2:创建对象并调用方法
        }
    }
    

    题目二:理解重写(Override)与运行时多态

    目标: 演示子类如何重写父类方法,以及通过父类引用变量指向子类对象时,运行时多态的体现。

    任务:

    1. 创建一个名为 Vehicle 的父类。
      • Vehicle 类包含一个公共方法 startEngine(),打印 "Vehicle engine started."。
    2. 创建两个子类 Car 和 Motorcycle,它们都继承自 Vehicle。
      • Car 类重写 startEngine() 方法,打印 "Car engine started with a roar!"。
      • Motorcycle 类重写 startEngine() 方法,打印 "Motorcycle engine kicked off with a vroom!"。
    3. 在 main 方法中:
      • 创建一个 Vehicle 类型的引用 v1,并使其指向一个 Car 对象。
      • 创建一个 Vehicle 类型的引用 v2,并使其指向一个 Motorcycle 对象。
      • 分别通过 v1 和 v2 调用 startEngine() 方法。
      • 预测并解释程序的输出结果。

    示例代码结构:

    class Vehicle {
        public void startEngine() {
            System.out.println("Vehicle engine started.");
        }
    }
    
    class Car extends Vehicle {
        // 重写 startEngine()
    }
    
    class Motorcycle extends Vehicle {
        // 重写 startEngine()
    }
    
    public class TestPolymorphism {
        public static void main(String[] args) {
            Vehicle v1 = new Car();
            Vehicle v2 = new Motorcycle();
    
            v1.startEngine();
            v2.startEngine();
        }
    }
    

    题目三:深入理解构造器中的多态行为

    目标: 考察在父类构造函数中调用可被子类重写的方法时,多态性如何发挥作用。

    任务:

    1. 创建一个名为 Parent 的父类。
      • Parent 类包含一个公共方法 display(),打印 "Parent's display method."。
      • 在 Parent 类的构造函数中,调用 display() 方法。
    2. 创建一个名为 Child 的子类,继承自 Parent。
      • Child 类重写 display() 方法,打印 "Child's display method."。
    3. 在 main 方法中:
      • 创建 Child 类的实例对象:Child c = new Child();
      • 预测并解释程序的完整输出结果,特别是 Child 对象创建时的行为。

    示例代码结构:

    class Parent {
        public Parent() {
            System.out.println("Parent Constructor called.");
            display(); // 调用 display 方法
        }
    
        public void display() {
            System.out.println("Parent's display method.");
        }
    }
    
    class Child extends Parent {
        public Child() {
            System.out.println("Child Constructor called.");
        }
    
        @Override
        public void display() {
            System.out.println("Child's display method.");
        }
    }
    
    public class TestConstructorPolymorphism {
        public static void main(String[] args) {
            Child c = new Child();
        }
    }
    

    题目四:成员变量与多态的辨析

    目标: 理解成员变量不具备多态性,其访问行为取决于引用变量的声明类型。

    任务:

    1. 创建一个名为 Animal 的父类。
      • Animal 类包含一个公共的 String 类型成员变量 type,初始化为 "General Animal"。
    2. 创建一个名为 Dog 的子类,继承自 Animal。
      • Dog 类也包含一个公共的 String 类型成员变量 type,初始化为 "Domestic Dog"。
    3. 在 main 方法中:
      • 创建一个 Animal 类型的引用 myAnimal,并使其指向一个 Dog 对象:Animal myAnimal = new Dog();
      • 打印 myAnimal.type 的值。
      • 预测并解释程序的输出结果。

    示例代码结构:

    class Animal {
        public String type = "General Animal";
    }
    
    class Dog extends Animal {
        public String type = "Domestic Dog";
    }
    
    public class TestMemberVariablePolymorphism {
        public static void main(String[] args) {
            Animal myAnimal = new Dog();
            System.out.println(myAnimal.type);
        }
    }
    

    题目五:综合应用与分析

    目标: 综合运用重载、重写以及成员变量的特性,分析复杂代码的执行流程和输出。

    任务:

    1. 阅读并理解以下 Java 代码。
    2. 不运行代码,预测程序的最终输出结果。
    3. 详细解释您的预测理由,指出哪些地方体现了重载,哪些地方体现了重写,以及成员变量的访问规则。
    class A {
        public int value = 10;
    
        public void printInfo() {
            System.out.println("Class A: " + value);
        }
    
        public void calculate(int x) {
            System.out.println("A's calculate(int): " + (value + x));
        }
    
        public void calculate(double d) {
            System.out.println("A's calculate(double): " + (value * d));
        }
    }
    
    class B extends A {
        public int value = 20;
    
        @Override
        public void printInfo() {
            System.out.println("Class B: " + value);
        }
    
        public void calculate(int x) { // 注意这里是重写了父类同名同参数方法
            System.out.println("B's calculate(int): " + (value + x + 5));
        }
    }
    
    public class TestComplexPolymorphism {
        public static void main(String[] args) {
            A obj1 = new A();
            B obj2 = new B();
            A obj3 = new B(); // 向上转型
    
            System.out.println("--- obj1 (A type, A object) ---");
            System.out.println("Value: " + obj1.value);
            obj1.printInfo();
            obj1.calculate(5);
            obj1.calculate(2.5);
    
            System.out.println("\n--- obj2 (B type, B object) ---");
            System.out.println("Value: " + obj2.value);
            obj2.printInfo();
            obj2.calculate(5);
            // obj2.calculate(2.5); // 这行代码会报错吗?为什么?请分析。
    
            System.out.println("\n--- obj3 (A type, B object) ---");
            System.out.println("Value: " + obj3.value);
            obj3.printInfo();
            obj3.calculate(5);
            obj3.calculate(2.5);
        }
    }
    

    提交与评估标准:

    • 代码可运行性: 您提供的代码(除了题目五的分析题)应该能够直接编译并运行,得到正确的输出。
    • 输出准确性: 对于要求预测输出的题目,您的预测必须与实际运行结果一致。
    • 解释清晰度: 对于要求解释的题目,您的解释应该逻辑清晰,准确引用多态性相关的概念(编译时多态、运行时多态、动态绑定、成员变量的遮蔽等)。
    • 对概念的理解: 答案应充分体现对重载、重写、构造器中方法调用以及成员变量与多态之间区别的深刻理解。

    祝您实践顺利!

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