java 子类Student继承自父类Person，并重写父类的方法。（重写练习）

好的，下面是示例代码：

public class Person {
    public void introduce() {
        System.out.println("我是人类。");
    }
}

public class Student extends Person {
    @Override
    public void introduce() {
        System.out.println("我是学生。");
    }
}

在上面的代码中，`Person`是父类，有一个`introduce`方法输出“我是人类”。`Student`是子类，继承了`Person`的`introduce`方法，并在子类中重写了该方法，输出“我是学生”。

这样，在使用`Student`的对象调用`introduce`方法时，会输出“我是学生”而不是“我是人类”。

相关问题

子类Student继承自父类Person，并重写父类的方法。（重写练习）

好的，这是一个简单的练习示例：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print(f"Hi, my name is {self.name} and I am {self.age} years old.")

class Student(Person):
    def __init__(self, name, age, school):
        super().__init__(name, age)
        self.school = school

    def introduce(self):
        print(f"Hi, my name is {self.name}, I am {self.age} years old, and I go to {self.school}.")

person1 = Person("John", 25)
person1.introduce()

student1 = Student("Jane", 20, "ABC University")
student1.introduce()

在这个示例中，我们定义了一个`Person`类和一个`Student`类。`Student`类继承自`Person`类，这意味着它具有`Person`类中定义的所有属性和方法。

但是，我们在`Student`类中重写了`introduce`方法，并添加了一个新属性`school`。在`Student`类中的`introduce`方法中，我们使用`super()`函数调用`Person`类中的`introduce`方法，以便保留`Person`类中的行为。然后，我们添加了一些额外的信息，以便更好地介绍学生。

最后，我们创建了一个`Person`对象和一个`Student`对象，并分别调用它们的`introduce`方法。你可以看到，当我们调用`Person`对象的`introduce`方法时，只会输出基本信息，而当我们调用`Student`对象的`introduce`方法时，会输出更详细的信息。这就是方法重写的效果。

子类Student类继承父类、并重写父类的printInfo()，使得子类的printInfo()能够返回所有属性信息，包括从父类中继承的属性。再定义测试类，在main方法中创建Student对象，验证Student类中重写的printInfo()的正确性。

在面向对象编程中，比如在Java中，如果有一个父类`Person`，包含了一些通用属性如姓名和年龄，我们可以通过创建一个新的子类`Student`来继承这些属性，并添加特有的属性，例如学号或专业。为了体现多态，子类可以重写父类的方法，如`printInfo()`。

首先，让我们定义一下`Person`类：

public class Person {
    private String name;
    private int age;

    // 构造函数、getter和setter省略

    public void printInfo() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

然后，我们将`Student`类继承自`Person`，并重写`printInfo()`方法：

public class Student extends Person {
    private String studentId;
    private String major;

    // 构造函数、getter和setter省略

    @Override
    public void printInfo() {
        super.printInfo();
        System.out.println("Student ID: " + studentId + ", Major: " + major);
    }
}

接下来，我们创建一个测试类`Test`，并在`main`方法中创建`Student`对象，并验证`printInfo()`的正确性：

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("张三");
        student.setAge(20);
        student.setStudentId("123456");
        student.setMajor("计算机科学");

        student.printInfo(); // 这将打印出Person的信息以及Student特有的信息
    }
}

当你运行这个`Test`类，会看到输出结果类似这样的内容：

Name: 张三, Age: 20
Student ID: 123456, Major: 计算机科学

这就展示了多态性的应用，即通过子类重写父类的方法，实现了特定情况下的行为变化。