java中父类和子类都重写了tostring()方法，在主函数中该怎么调用

可以直接调用子类的toString()方法，因为子类重写了父类的toString()方法，所以会调用子类的toString()方法。如果想要调用父类的toString()方法，可以使用super关键字来调用。例如，如果子类为ChildClass，可以使用super.toString()来调用父类的toString()方法。

相关问题

设计一个抽象类名字为 Person,它的子类为Student和 Employee；person类有name以及toString方法；student有 status属性(freshman, sophomore, junior, or senior),定义status 为常量;Employee类 有office, salary；分别定义各个类的有参构造方法，Person(String name)、Student（String name,int status）、Employee(String name,String office,double salary),注意需要在子类构造方法第一句调用父类有参构造方法，为子类也实现toString方法。编写测试类定义一个数组存放每个非抽象类对象（Student和 Employee），然后利用多态调用toString方法打印各个对象的所有属性信息。(为了减少书写量，只需要为name属性完成get和set方法，其他属性不用写)

以下是您所描述的Person抽象类以及其子类Student和Employee的实现：

abstract class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Name: " + name;
    }
}

class Student extends Person {
    private String status;

    public static final String FRESHMAN = "Freshman";
    public static final String SOPHOMORE = "Sophomore";
    public static final String JUNIOR = "Junior";
    public static final String SENIOR = "Senior";

    public Student(String name, String status) {
        super(name);
        this.status = status;
    }

    public String getStatus() {
        return status;
    }

    @Override
    public String toString() {
        return super.toString() + ", Status: " + status;
    }
}

class Employee extends Person {
    private String office;
    private double salary;

    public Employee(String name, String office, double salary) {
        super(name);
        this.office = office;
        this.salary = salary;
    }

    public String getOffice() {
        return office;
    }

    public double getSalary() {
        return salary;
    }

    @Override
    public String toString() {
        return super.toString() + ", Office: " + office + ", Salary: " + salary;
    }
}

public class Main {
    public static void main(String[] args) {
        Person[] people = new Person[2];
        people[0] = new Student("Alice", Student.SOPHOMORE);
        people[1] = new Employee("Bob", "A101", 50000.0);

        for (Person person : people) {
            System.out.println(person.toString());
        }
    }
}

在上述代码中，我们定义了抽象类Person，并在其子类Student和Employee中实现了各自的属性和构造方法。Person类包含一个name属性和toString方法。Student类有一个status属性，定义了常量值作为status的选项，并重写了toString方法。Employee类有一个office属性和salary属性，并重写了toString方法。

在主函数中，我们创建了一个Person类型的数组，并存放了一个Student对象和一个Employee对象。通过多态性，我们调用了toString方法打印出每个对象的属性信息。注意，为了简化代码，只为name属性编写了get和set方法。其他属性的get和set方法可以按照相同的方式添加。

java面对对象编程题

### Java 面向对象编程练习题

#### 练习一：创建学生类并测试其功能

定义一个 `Student` 类，该类应具备如下属性和行为：

- 年龄 (`age`)
- 成绩 (`grade`)

- 方法：
- 获取个人信息的方法 `getInfo()` ，用于打印学生的姓名、年龄以及成绩。

编写一段程序来验证这个类的功能。通过实例化不同的学生对象，并调用它们的 `getInfo()` 方法显示信息[^1]。

class Student {
    String name;
    int age;
    double grade;

    public void getInfo() {
        System.out.println("Name: " + this.name);
        System.out.println("Age: " + this.age);
        System.out.println("Grade: " + this.grade);
    }
}

public class Main {
    public static void main(String[] args) {
        Student studentA = new Student();
        studentA.name = "Alice";
        studentA.age = 20;
        studentA.grade = 87.5;
        
        studentA.getInfo();

        Student studentB = new Student();
        studentB.name = "Bob";
        studentB.age = 22;
        studentB.grade = 92.3;
        
        studentB.getInfo();
    }
}

此代码展示了如何利用面向对象的思想简化对学生数据的操作管理，同时也体现了封装的概念——将数据与操作这些数据的方法捆绑在一起。

#### 练习二：实现员工继承关系及其多态特性

设计两个类 `Employee` 和它的子类 `Manager` 。其中 `Employee` 包含基本的信息如名字(`name`)；而 `Manager` 则额外拥有部门名称(`department`)这一属性。重写 `toString()` 方法以便于更友好地展示每个对象的内容。最后，在主函数中创建不同类型的员工对象并通过统一接口访问它们的数据，以此展现Java中的多态性特点[^2]。

// 定义 Employee 类作为基类
class Employee {
    protected String name;

    @Override
    public String toString(){
        return "Employee Name:" + this.name;
    }

    // 构造器
    public Employee (String n){
       this.name=n; 
    }
}

// Manager 是 Employee 的子类
class Manager extends Employee{
    private String department;

    // 调用了父类构造器初始化 name 字段
    public Manager(String n, String d){
      super(n);  
      this.department=d;
    }

    @Override
    public String toString(){
         return "Manager Name:"+super.toString()+" Department:"+this.department ;
    }
}

public class Main {
     public static void show(Employee emp){
          System.out.println(emp.toString());
     }

     public static void main(String []args){
           Employee e=new Employee ("John");
           Manager m= new Manager("Mike","Sales");

           show(e); // 输出普通雇员信息
           show(m); // 输出经理信息，这里会自动调用到覆盖后的版本
     }
}

这段代码不仅实现了简单的继承机制，还展现了当子类提供了特定的行为时，即使变量被声明为父类型也可以正确执行相应逻辑的能力，这正是面向对象编程的核心优势之一。