Java. Superconstructorul implicit Employee() este nedefinit. Trebuie invocat explicit un alt constructor [duplicat] (Programare, Java, Constructor, Superclasa)

user659658 a intrebat.

Bună ziua, sunt nou în Java, primesc această eroare în clasa mea de lucrător de producție. Constructorul meu Production worker spune să invoce explicit un alt constructor. Nu știu ce să fac?

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

Comentarii

  • puneți un constructor implicit în clasa Employee. public Employee(){} –  > Por user489041.
6 răspunsuri
xappymah

Orice constructor pentru orice clasă, după cum știți, creează un obiect. Deci, constructorul ar trebui să conțină un cod de inițializare adecvat pentru clasa sa. Dar dacă aveți o clasă care extinde o alta (să o numim „părinte”), atunci constructorul pentru clasă nu poate conține tot codul necesar pentru inițializare prin definiție (de exemplu, nu puteți defini câmpuri private ale părintelui). De aceea, constructorul clasei trebuie să apeleze constructorul clasei părinte. Dacă nu îl apelați în mod explicit, atunci este apelat constructorul implicit al părintelui (care este fără niciun parametru).

Prin urmare, în cazul dvs., puteți fie să implementați constructorul implicit în clasa părinte, fie să apelați direct orice constructor din clasă.

Comentarii

  • Constructorul implicit este de genul următor public Employee(String hourlyrate, String shift) { shift = „”; hourlyrate = „”; } –  > Por user659658.
  • Nu, prin constructor implicit se înțelege un constructor fără parametri, cum ar fi public Employee(){} – – public Employee(){}.  > Por Erkan Haspulat.
  • Am făcut acest lucru și tot primesc aceeași eroare. –  > Por user659658.
  • Nu, „constructor implicit” este un constructor care nu acceptă niciun parametru: public Employee() { /* Code here */ } –  > Por xappymah.
  • Constructorii nu creează obiecte, ci doar le inițializează. –  > Por Joachim Sauer.
Bartzilla

După cum au menționat deja alții, trebuie să furnizați un constructor implicit public Employee(){} în Employee clasă.

Ceea ce se întâmplă este că compilatorul furnizează automat un constructor implicit, fără argumente, pentru orice clasă fără constructori. Dacă clasa dvs. nu are un constructor explicit superclasa, , atunci are o superclasă implicită de Object, , care are un constructor fără argument. În acest caz, declarați un constructor în clasa dvs. Employee prin urmare, trebuie să trebuie să să furnizați, de asemenea, constructorul fără argument.

Acestea fiind spuse Employee clasa ar trebui să arate astfel:

Clasa dumneavoastră 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;
      }
}

Iată tutorialul Java Oracle – Furnizarea de constructori pentru clasele dvs. capitol. Parcurgeți-l și veți avea o idee mai clară despre ceea ce se întâmplă.

Erkan Haspulat

ProductionWorker extinde Employee, , astfel se spune că are toate capacitățile unui angajat. Pentru a realiza acest lucru, Java pune în mod automat un super(); apel în prima linie a fiecărui constructor, îl puteți pune manual, dar de obicei nu este necesar. În cazul dvs. este necesar, deoarece apelul către super(); nu poate fi plasat automat din cauza faptului că constructorul lui Employee are parametri.

Trebuie fie să definiți un constructor implicit în Employee fie să apelați super('Erkan', 21, new Date()); în prima linie a constructorului din ProductionWorker.

Comentarii

  • Nu are nimic de-a face cu tipurile de parametri. Este necesar un apel explicit la un constructor al clasei părinte, deoarece aceasta nu are un constructor fără argumente. –  > Por Isaac Truett.
  • ceilalți au răspuns greșit, nu trebuie să aveți constructori impliciți, cum ar fi public Employee(){}; trebuie doar să apelați constructorii clasei super. în interiorul constructorului copiilor săi. astfel: public ProductionWorker(int shift, double hourlyrate) { super(name, number, date); setShift(shift); setHourlyPayRate(hourlyrate); } –  > Por M D P.
Isaac Truett

Este necesar un apel explicit la constructorul clasei părinte ori de câte ori clasa părinte nu are un constructor fără argument. Puteți fie să adăugați un constructor fără argument la clasa părinte, fie să apelați explicit constructorul clasei părinte în clasa copil.

Brad Parks

Această problemă poate apărea, de asemenea, atunci când nu aveți constructorul dvs. imediat să apeleze super.

Deci, acest lucru va funcționa:

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

Dar asta nu:

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

    super(....)
  }

Motivul pentru care al doilea exemplu eșuează este că java încearcă să apeleze implicit la

super(name,number,date)

ca prima linie din constructorul dumneavoastră…. Deci, java nu vede că aveți un apel la super mai târziu în constructor. În esență, încearcă să facă acest lucru:

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

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

    super(....)
  }

Deci, soluția este destul de simplă… Pur și simplu nu puneți cod înainte de super call 😉 Dacă aveți nevoie să inițializați ceva înainte de apelul la super, faceți-o într-un alt constructor, apoi apelați vechiul constructor… Ca în acest exemplu extras din acest mesaj de pe StackOverflow:

public class Foo
{
    private int x;

    public Foo()
    {
        this(1);
    }

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

Brent Ivey

Am avut această problemă recent în laboratorul meu de informatică. Este simplă și Erkan a răspuns corect. Trebuie doar să puneți super("the name of your subclass") Deci, în legătură cu problema ta –> super("ProductionWorker); ca prima linie a textului tău subclass' constructor.