Java。隐式超级构造函数Employee（）未定义。必须显式调用另一个构造函数

Question

你好我是Java的新手，我在我的生产工人类中遇到了这个错误。我的生产工人构造函数说明确地调用另一个构造函数。我不知道该怎么办？。

import java.util.Date; 

public class Employee 
{ 
     private String name, number; 
     private Date date; 

     public Employee(String name, String number, Date date) 
     { 
      setName(name); 
      setNumber(number); 
      setDate(date); 
     } 

     public void setName(String n) 
     { 
      name = n; 
     } 
     public void setNumber(String n) 
     { 
      number = n; 
      // you can check the format here for correctness 
     } 
     public void setDate(Date d) 
     { 
      date = d; 
     } 

     public String getName() 
     { 
      return name; 
     } 
     public String getNumber() 
     { 
      return number; 
     } 
     public Date getDate() 
     { 
      return date; 
     } 
} 



public class ProductionWorker extends Employee 
{ 
     private int shift; 
     private double hourlyrate; 
     // error is here (Implicit super constructor Employee() is undefined. Must explicitly invoke another constructor). 
     public ProductionWorker(int shift, double hourlyrate) 
     { 
      setShift(shift); 
      setHourlyPayRate(hourlyrate); 
     } 

     public void setShift(int s) 
     { 
      shift = s; 
     } 
     public void setHourlyPayRate(double rate) 
     { 
      hourlyrate = rate; 
     } 

     public int getShift() 
     { 
      return shift; 
     } 
     public double getHourlyPayRate() 
     { 
      return hourlyrate; 
     } 
} 

Answer 1

任何类的构造函数都可以创建一个对象。所以，构造函数应该包含它的类的正确的初始化代码。但是如果你有一个扩展另一个类的类（我们称之为“父类”），那么这个类的构造函数不能包含定义初始化所需的所有代码（例如，你不能定义父类的私有字段）。这就是为什么类的构造函数必须调用其父类的构造函数。如果你没有明确地调用它，那么调用默认的父构造函数（没有任何参数）。

因此，就你而言，你可以在父类中实现默认构造函数，或者直接调用类中的任何构造函数。

Answer 2

ProductionWorker延伸Employee，因而据说它有一个Employee的所有功能。为了做到这一点，Java会自动在每个构造函数的第一行中放入一个​​调用，您可以手动将其放入，但通常不是必需的。在你的情况下，它是必要的，因为由于Employee的构造函数具有参数，所以不能自动调用​​。

您可能需要在Employee类中定义默认构造函数，或者在ProductionWorker的构造函数的第一行中调用super('Erkan', 21, new Date());。

Answer 3

无论何时父类没有无参数构造函数，都需要对父类构造函数进行显式调用。您可以向父类添加无参数构造函数，或者在子类中显式调用父类构造函数。

Answer 4

正如其他人已经提到，您需要在您的Employee类中提供默认构造函数public Employee(){}。

会发生什么情况是编译器会自动为任何没有构造函数的类提供一个无参数的默认构造函数。如果你的班级没有明确的超类，那么它有一个隐含的超类Object，其中确实有无参数构造函数。在这种情况下，你正在类中声明一个构造函数Employee因此你必须必须也提供了无参数的构造函数。

话虽如此Employee类应该是这样的：

你Employee类

import java.util.Date; 

public class Employee 
{ 
     private String name, number; 
     private Date date; 

     public Employee(){} // No-argument Constructor 

     public Employee(String name, String number, Date date) 
     { 
      setName(name); 
      setNumber(number); 
      setDate(date); 
     } 

     public void setName(String n) 
     { 
      name = n; 
     } 
     public void setNumber(String n) 
     { 
      number = n; 
      // you can check the format here for correctness 
     } 
     public void setDate(Date d) 
     { 
      date = d; 
     } 

     public String getName() 
     { 
      return name; 
     } 
     public String getNumber() 
     { 
      return number; 
     } 
     public Date getDate() 
     { 
      return date; 
     } 
} 

这里是甲骨文的Java教程 - Providing Constructors for Your Classes章。通过它，你会对发生了什么有更清晰的认识。

Answer 5

最近在我的实验室有这个问题。这很简单，Erkan正确回答。只要把super("the name of your subclass")作为你的subclass'构造函数的第一行就可以了 - >super("ProductionWorker);。

Answer 6

这个问题也可以出现，当你没有你的构造函数立即调用超级。

那么这将工作：

public Employee(String name, String number, Date date) 
    { 
    super(....) 
    } 

但这不会：

public Employee(String name, String number, Date date) 
    { 
    // an example of *any* code running before you call super. 
    if (number < 5) 
    { 
     number++; 
    } 

    super(....) 
    } 

第二个例子失败的原因是因为Java是试图隐含调用

super(name,number,date) 

作为构造函数中的第一行......所以java并没有看到你在调用后面的超级函数uctor。它实质上是尝试做到这一点：

public Employee(String name, String number, Date date) 
    { 
    super(name, number, date); 

    if (number < 5) 
    { 
     number++; 
    } 

    super(....) 
    } 

因此，解决办法是很容易...只要你超级调用之前不把代码;-)如果需要调用超级前初始化的东西，这样做的另一个构造函数，然后调用构造函数老...就像这个例子pulled from this StackOverflow post：

public class Foo 
{ 
    private int x; 

    public Foo() 
    { 
     this(1); 
    } 

    public Foo(int x) 
    { 
     this.x = x; 
    } 
}