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

当我运行这段代码时，我只是想用班次详细信息和员工填充一个列表，我已经在super类中预先制作了一个员工生成器，所以我认为最好不要重复代码。我可以创建并填充shift数组列表，但每次创建shift对象时，它都会显示

EmployeeSheet

字段

以下是

员工工作表

课程：

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();
    }
}

import java.util.*；
公共类员工表
扩展员工{
私人ArrayList公司；
私人生产工人；
二等兵；
/**
*构建随机选择的员工列表并显示该列表。
*/
公共雇员表（）{
empSheet=newarraylist（）；
随机选取器=新随机（）；
对于（int i=0；i<20；i++）{
int id=empicker.nextInt（20）；
if（id<12）//生产工人卷
{
System.out.println（“添加生产工人”）；
添加（generateProductionWorker（））；
}else//轮班主管登记
{
System.out.println（“添加值班主管”）；
添加（generateShiftSupervisor（））；
}
}
迭代器迭代器=empSheet.Iterator（）；
while（iterator.hasNext（））{
System.out.println（“”）；
System.out.println（iterator.next（））；
}
}
/**
*生成生产工人
*@返回组成生产工人的字段
*/
公共生产工人一代生产工人（）{
随机rng=新随机（）；
int numberOfEmployeeNames=Ename.length；
ProductionWorker tempPworker=新ProductionWorker（）；
字符串employeeName=Ename[rng.nextInt（numberOfEmployeeNames）]；
tempWorker.setEmployeeName（employeeName）；
int numberOfEmployeeNumbers=Empnum.length；
字符串employeeNumber=Empnum[rng.nextInt（numberOfEmployeeNumbers）]；
tempPworker.setEmployeeNumber（employeeNumber）；
国际雇佣年=rng.nextInt（35）+1980年；
临时工。setEmployeehireyear（雇佣年）；
双周工资=rng.nextInt（（100）*100）；
tempPworker.SetEmployeeWeekleForwarding（每周一次）；
整小时利率=rng.nextInt（20）+10；
临时工设置小时费率（小时费率）；
工友=临时工友；
返回临时工；
}
/**
*生成ShiftsPervisor员工
*@返回构成值班主管的字段
*/
公共班长主管发电机提升主管（）{
Random ran=新的Random（）；
int numberOfEmployeeNames=Ename.length；
ShiftsPervisor tempSworker=新的ShiftsPervisor（）；
字符串employeeName=Ename[ran.nextInt（numberOfEmployeeNames）]；
tempSworker.setEmployeeName（employeeName）；
int numberOfEmployeeNumbers=Empnum.length；
字符串employeeNumber=Empnum[ran.nextInt（numberOfEmployeeNumbers）]；
tempSworker.setEmployeeNumber（employeeNumber）；
int yearHired=ran.nextInt（35）+1900；
tempSworker.setEmployeehireyear（雇佣年）；
双周日历=ran.nextInt（（100）*100）；
tempSworker.SetEmployeeWeekleDressing（每周一次）；
int goalsMet=ran.nextInt（100）+1；
tempSworker.setGoalsCleared（goalsMet）；
双年度平均值=ran.nextInt（（40000）+40000）；
tempSworker.setYearlySalary（yearlySalary）；
斯沃克=坦普斯沃克；
返回坦普斯沃克；
}
公共int checkSize（）{
返回empSheet.size（）；
}
}

这是班次：

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;

    }

}

import java.util.*；
公共阶级转移
扩展员工表{
私有数组列表移位细节；
私人生产工人；
二等兵；
公共班次（）{
这个。generateShift（）；
}
//实例变量-将下面的示例替换为您自己的
/**
*类Shift对象的构造函数
*/
公共void generateShift（）{
shiftDetails=newArrayList（）；
Random supervisorCount=新随机数（）；
int ssID=监管者计数下一个（3）；
对于（int i=0；i

知道为什么会这样吗

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

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

每次创建shift对象时，它都会显示EmployeeSheet字段

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

知道为什么会这样吗

因为轮班延长了员工工作表

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

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

每次创建shift对象时，它都会显示EmployeeSheet字段

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

知道为什么会这样吗

---

因为Shift扩展了EmployeeSheet。

用Java编写的任何构造函数都是从调用另一个构造函数开始的。如果没有显式编写，编译器会为您编写以下行作为构造函数的第一行：

super();

那