为什么子类运行超类构造函数？

Question

当我运行这段代码只是试图用班次详细信息和员工填充列表时，我在超级 class 中预制了一个员工生成器，所以我认为这是一个很好的做法不重复代码。我能够创建移位数组列表并填充它，但每次我创建移位对象时它都会显示 EmployeeSheet 字段。

这是 EmployeeSheet class :

import java.util.*;

public class EmployeeSheet
        extends Employee {
    private ArrayList<Employee> empSheet;
    private ProductionWorker pworker;
    private ShiftSupervisor sworker;

    /**
     * Constructs a list of randomly selected employees and displays the list.
     */
    public EmployeeSheet() {
        empSheet = new ArrayList<Employee>();

        Random empPicker = new Random();

        for (int i = 0; i < 20; i++) {
            int id = empPicker.nextInt(20);
            if (id < 12) // roll for production worker
            {
                System.out.println("Adding Production Worker");
                empSheet.add(generateProductionWorker());
            } else //roll for Shift supervisor
            {
                System.out.println("Adding Shift supervisor");
                empSheet.add(generateShiftSupervisor());
            }
        }
        Iterator iterator = empSheet.iterator();
        while (iterator.hasNext()) {
            System.out.println("");
            System.out.println(iterator.next());

        }
    }

    /**
     * Generates a Production Worker
     * @return The fields that make up a Production worker
     */

    public ProductionWorker generateProductionWorker() {
        Random rng = new Random();
        int numberOfEmployeeNames = Ename.length;
        ProductionWorker tempPworker = new ProductionWorker();

        String employeeName = Ename[rng.nextInt(numberOfEmployeeNames)];
        tempPworker.setEmployeeName(employeeName);

        int numberOfEmployeeNumbers = Empnum.length;
        String employeeNumber = Empnum[rng.nextInt(numberOfEmployeeNumbers)];
        tempPworker.setEmployeeNumber(employeeNumber);

        int yearHired = rng.nextInt(35) + 1980;
        tempPworker.setEmployeehireyear(yearHired);

        double weeklySalary = rng.nextInt((100) * 100);
        tempPworker.setEmployeeweeklyearning(weeklySalary);

        int hourlyRate = rng.nextInt(20) + 10;
        tempPworker.setHourlyRate(hourlyRate);

        pworker = tempPworker;

        return tempPworker;

    }

    /**
     * Generates a ShiftSupervisor employee
     * @return the Fields that make up a shift supervisor
     */

    public ShiftSupervisor generateShiftSupervisor() {
        Random ran = new Random();
        int numberOfEmployeeNames = Ename.length;
        ShiftSupervisor tempSworker = new ShiftSupervisor();

        String employeeName = Ename[ran.nextInt(numberOfEmployeeNames)];
        tempSworker.setEmployeeName(employeeName);

        int numberOfEmployeeNumbers = Empnum.length;

        String employeeNumber = Empnum[ran.nextInt(numberOfEmployeeNumbers)];
        tempSworker.setEmployeeNumber(employeeNumber);

        int yearHired = ran.nextInt(35) + 1900;
        tempSworker.setEmployeehireyear(yearHired);

        double weeklySalary = ran.nextInt((100) * 100);
        tempSworker.setEmployeeweeklyearning(weeklySalary);

        int goalsMet = ran.nextInt(100) + 1;
        tempSworker.setGoalsCleared(goalsMet);

        double yearlySalary = ran.nextInt((40000) + 40000);
        tempSworker.setYearlySalary(yearlySalary);

        sworker = tempSworker;

        return tempSworker;

    }

    public int checkSize() {
        return empSheet.size();
    }
}

这里是班次 class :

import java.util.*;

public class Shift
        extends EmployeeSheet {

    private ArrayList<Employee> shiftDetails;
    private ProductionWorker pWorker;
    private ShiftSupervisor sWorker;

    public Shift() {
        this.generateShift();

    }
    // instance variables - replace the example below with your own


    /**
     * Constructor for objects of class Shift
     */

    public void generateShift() {
        shiftDetails = new ArrayList();

        Random supervisorCount = new Random();
        int ssID = supervisorCount.nextInt(3);
        for (int i = 0; i < ssID; i++) {

            shiftDetails.add(this.generateShiftSupervisor());
        }

        Random productionCount = new Random();
        int prodID = productionCount.nextInt(15) + 5;
        for (int d = 0; d < prodID; d++) {

            shiftDetails.add(this.generateProductionWorker());
        }
    }

    public ProductionWorker generateProductionWorker() {
        pWorker = super.generateProductionWorker();
        return pWorker;
    }
    public ShiftSupervisor generateShiftSupervisor() {
        sWorker = super.generateShiftSupervisor();
        return sWorker;

    }

}

知道为什么会这样吗？

Answer 1

Why does subclass run Superclass constructor?

构造基础对象。否则它将是未构造的并且继承语义将是不完整的。

everytime I create the shift object it displays the EmployeeSheet fields.

因为 EmployeeSheet 的构造函数显示了这些字段。

Any ideas why this is happening?

因为 Shift 扩展了 EmployeeSheet。

Answer 2

您在 Java 中编写的任何构造函数都以调用另一个构造函数开始。如果您不显式编写它，那么编译器会为您编写以下行作为构造函数的第一行：

super();

这意味着要构造任何实例，您需要先构造父实例class（没有父实例的对象class除外）。

从 Object Oriented Programming 的角度来看这是有道理的，因为当 A 继承自 B 时，这意味着 A "is a" B 具有某些特定的状态或行为。在您的情况下，您似乎没有使用继承来描述 "is a" 关系，这可能是一个设计错误。

我的意思是，EmployeeSheet 似乎没有 "is a" Employee。你最好只使用 Composition.

来模拟这种关系

为什么子类运行超类构造函数？

Why does subclass run Superclass constructor?

java

inheritance

arraylist

为什么子类 运行 超类构造函数？

Why does subclass run Superclass constructor?

java

inheritance

arraylist

为什么子类运行超类构造函数？