Java:为什么需要构造函数来使用父类中的对象？

Question

编辑 2:顺便说一句，我在类里面的代码有效并通过了所有测试人员。我只是想全神贯注于构造函数。日期 d 是一个对象； Date 的构造函数的产物，对吗？因此，如果 IncDate 是一个 Date(我认为这就是 extends 的意思)，它是否可以访问 Date 的构造函数并因此能够创建新的 Date 对象和/或使用它们？再一次，伙计们，非常感谢!

例如:我在数据结构类中学习的类看起来像这样。这是子类的构造函数:

public class IncDate extends Date
public IncDate(int newMonth, int newDay, int newYear)
{
    super(newMonth, newDay, newYear);
}

 public void increment()
{
    Date d = inverseLilian(lilian() + 1);
    month = d.month;
    day = d.day;
    year = d.year;
}

这是父类的构造函数:

   public Date(int newMonth, int newDay, int newYear)
{
    month = newMonth;
    day = newDay;
    year = newYear;
}

所以这是我的问题。如果函数“扩展”基本上是让子类访问它的方法和对象，那么我真的需要在子类中创建一个新的构造函数以便我可以使用在父类中创建的 Date 对象吗？这让我很困惑。如果有的话，所有的 IncDate 构造函数都会继承父类构造函数的值，但它不会继承使用 Date 对象的选项，因为 extends 基本上意味着“是一个”，所以 IncDate 是一个 Date 类，因此它应该可以选择创建和使用 Date 对象而无需创建自己的构造函数。我很困惑。

TL;DR:如果我删除 IncDate 构造函数，增量方法中的 Date 对象将不起作用。为什么？

谢谢大家。你在这里帮了大忙!

编辑:因为有人问，这里是 Date 类中的 inverseLilian 和 lilian 方法。

    public Date inverseLilian(int lilian)
{
    int temp = ((lilian + 139444) * 100) / 3652425;
    int days = temp + lilian + 139444 - (temp / 4);
    temp  = days * 100 / 36525;
    if((days * 100) % 36525 == 0)
        temp -= 1;
    days = days - (temp * 36525 / 100);
    int years = temp + 1201;

    // account for leap year
    int leapDay = 0;
    if (years % 4 == 0)   leapDay ++;
    if (years % 100 == 0) leapDay --;
    if (years % 400 == 0) leapDay ++;

    if (days > leapDay + 59) days += (2 - leapDay);
    int months = (((days + 91) * 100) / 3055);
    days = (days + 91) - ((months * 3055) / 100);
    months -= 2;

    return new Date(months,days,years);
}


    public int lilian()
{
    // Returns the Lilian Day Number of this date.
    // Precondition: This Date is a valid date after 10/14/1582.
    //
    // Computes the number of days between 1/1/0 and this date as if no calendar
    // reforms took place, then subtracts 578,100 so that October 15, 1582 is day 1. 

    final int subDays = 578100;  // number of calculated days from 1/1/0 to 10/14/1582

    int numDays = 0;

    // Add days in years.
    numDays = year * 365;

    // Add days in the months.
    if (month <= 2) 
        numDays = numDays + (month - 1) * 31;
    else 
        numDays = numDays + ((month - 1) * 31) - ((4 * (month-1) + 27) / 10);

    // Add days in the days.
    numDays = numDays + day;

    // Take care of leap years.
    numDays = numDays + (year / 4) - (year / 100) + (year / 400);

    // Handle special case of leap year but not yet leap day.
    if (month < 3) 
    {
        if ((year % 4) == 0)   numDays = numDays - 1;
        if ((year % 100) == 0) numDays = numDays + 1;
        if ((year % 400) == 0) numDays = numDays - 1;
    }

    // Subtract extra days up to 10/14/1582.
    numDays = numDays - subDays;
    return numDays;

Answer 1

因为构造函数不像普通方法那样被继承。因此，父类中的构造函数不能直接供子类使用。

但是您仍然可以从子类构造函数中调用父构造函数。

所以解决方案是在子类中创建一个构造函数，然后子类调用父类中的构造函数。