wake-up-neo.net

Java-Standardkonstruktor

Was genau ist ein Standardkonstruktor - können Sie mir sagen, welcher der folgenden ein Standardkonstruktor ist und was ihn von jedem anderen Konstruktor unterscheidet?

public Module() {
   this.name = "";
   this.credits = 0;
   this.hours = 0;
}

public Module(String name, int credits, int hours) {
   this.name = name;
   this.credits = credits;
   this.hours = hours;
}
137
antanis

Keiner von ihnen. Wenn Sie es definieren, ist es nicht die Standardeinstellung.

Der Standardkonstruktor ist der Konstruktor ohne Argumente, der automatisch generiert wird, sofern Sie keinen anderen Konstruktor definieren. Alle nicht initialisierten Felder werden auf ihre Standardwerte gesetzt. In Ihrem Beispiel würde dies folgendermaßen aussehen, vorausgesetzt, die Typen sind String, int und int und die Klasse selbst ist public:

public Module()
{
  super();
  this.name = null;
  this.credits = 0;
  this.hours = 0;
}

Das ist genau das gleiche wie

public Module()
{}

Und genau so, als hätte man überhaupt keine Konstruktoren. Wenn Sie jedoch mindestens einen Konstruktor definieren, wird der Standardkonstruktor nicht generiert.

Referenz: Java-Sprachspezifikation

Wenn eine Klasse keine Konstruktordeklarationen enthält, wird implizit ein Standardkonstruktor ohne formale Parameter und ohne throws-Klausel deklariert. 

Klärung

Technisch ist es nicht der Konstruktor (Standard oder anderweitig), der die Felder standardmäßig initialisiert. Allerdings lasse ich es die Antwort da 

  • die Frage hat die Standardeinstellungen falsch gemacht, und 
  • der Konstruktor hat genau denselben Effekt, ob er enthalten ist oder nicht.
223
OrangeDog

Ein Standardkonstruktor wird erstellt, wenn Sie in Ihrer Klasse keine Konstruktoren definieren. Es ist einfach kein Argumentkonstruktor, der nichts tut. Edit: Außer call super ()

public Module(){
}
31
Jim

Ein Standardkonstruktor wird automatisch vom Compiler generiert, wenn Sie nicht mindestens einen Konstruktor in Ihrer Klasse explizit definieren. Sie haben zwei definiert, sodass Ihre Klasse keinen Standardkonstruktor hat.

Per The Java Language Specification Dritte Ausgabe:

8.8.9 Default Constructor

Wenn eine Klasse keinen Konstruktor enthält Deklarationen, dann ein Standardwert Konstruktor, der keine Parameter verwendet wird automatisch bereitgestellt ...

19
kem

Hallo. Nach meinem Wissen möchte ich das Konzept des Standardkonstruktors klarstellen:

Der Compiler stellt automatisch einen Standardkonstruktor ohne Argument zur Verfügung für jede Klasse ohne Konstruktoren. Dieser Standardkonstruktor ruft .__ auf. der Konstruktor ohne Argumente der Oberklasse. In dieser Situation ist der Compiler wird sich beschweren, wenn die Superklasse kein Argument hat Konstruktor, so müssen Sie überprüfen, dass dies der Fall ist. Wenn Ihre Klasse keine .__ hat. explizite Oberklasse, dann hat es eine implizite Oberklasse von Objekt, was hat einen Konstruktor ohne Argumente.

Ich habe diese Informationen aus den Java Tutorials gelesen.

17
Koushik85

Java stellt einen Standardkonstruktor bereit, der keine Argumente akzeptiert und keine besonderen Aktionen oder Initialisierungen durchführt, wenn keine expliziten Konstruktoren bereitgestellt werden.

Die einzige Aktion, die der implizite Standardkonstruktor ausführt, ist das Aufrufen des Superklassenkonstruktors mithilfe des Aufrufs super (). Konstruktorargumente bieten Ihnen die Möglichkeit, Parameter für die Initialisierung eines Objekts bereitzustellen.

Unten sehen Sie ein Beispiel für eine Cube-Klasse, die 2 Konstruktoren enthält. (ein Standardkonstruktor und ein parametrisierter Konstruktor).

public class Cube1 {
    int length;
    int breadth;
    int height;
    public int getVolume() {
        return (length * breadth * height);
    }

    Cube1() {
        length = 10;
        breadth = 10;
        height = 10;
    }

    Cube1(int l, int b, int h) {
        length = l;
        breadth = b;
        height = h;
    }

    public static void main(String[] args) {
        Cube1 cubeObj1, cubeObj2;
        cubeObj1 = new Cube1();
        cubeObj2 = new Cube1(10, 20, 30);
        System.out.println("Volume of Cube1 is : " + cubeObj1.getVolume());
        System.out.println("Volume of Cube1 is : " + cubeObj2.getVolume());
    }
}
7
sunil

Allgemeine Terminologie besagt, dass, wenn Sie keinen Konstruktor in Ihrem Objekt angeben, automatisch kein Argumentkonstruktor platziert wird, der als Standardkonstruktor bezeichnet wird.

Wenn Sie einen Konstruktor definieren, der dem Konstruktor entspricht, der ohne Angabe eines Konstruktors platziert würde, wird er im Allgemeinen als Argumente Konstruktor bezeichnet. Dies ist jedoch nur eine Konvention, da einige Programmierer es vorziehen, diesen explizit definierten Konstruktor ohne Argumente als Standardkonstruktor zu nennen. Aber wenn wir mit der Benennung gehen, wenn wir eine explizit definieren, wird sie nicht als Standard festgelegt.

Wie in den Dokumenten

Wenn eine Klasse keine Konstruktordeklarationen enthält, wird implizit ein Standardkonstruktor ohne formale Parameter und ohne throws-Klausel deklariert.

Beispiel

public class Dog
{
}

wird automatisch (durch Hinzufügen des Standardkonstruktors) wie folgt geändert

public class Dog{
    public Dog() {

    }
} 

und wenn Sie es erstellen, ist es ein Objekt

 Dog myDog = new Dog();

dieser Standardkonstruktor wird aufgerufen.

5
Aniket Thakur

standardkonstruktor bezieht sich auf einen Konstruktor, der automatisch vom Compiler generiert wird, wenn keine vom Programmierer definierten Konstruktoren vorhanden sind.

Wenn vom Programmierer kein Konstruktor zur Verfügung gestellt wird, deklariert der Compiler implizit einen Standardkonstruktor, der super() aufruft, keine Wurfklausel sowie formale Parameter.

Z.B.

class Klass {
      // Default Constructor gets generated
} 

new Klass();  // Correct
-------------------------------------

class KlassParameterized {

    KlassParameterized ( String str ) {   //// Parameterized Constructor
        // do Something
    }
} 

new KlassParameterized(); //// Wrong  - you need to explicitly provide no-arg constructor. The compiler now never declares default one.


--------------------------------

class KlassCorrected {

    KlassCorrected (){    // No-arg Constructor
       /// Safe to Invoke
    }
    KlassCorrected ( String str ) {   //// Parameterized Constructor
        // do Something
    }
} 

new KlassCorrected();    /// RIGHT  -- you can instantiate
2
Yergalem

Wenn für eine Klasse kein Konstruktor vom Programmierer bereitgestellt wird, fügt der Java-Compiler einen Standardkonstruktor mit out-Parametern hinzu, der den Superklassenkonstruktor intern mit dem Aufruf von super () aufruft. Dies wird als Standardkonstruktor bezeichnet.

In Ihrem Fall gibt es keinen Standardkonstruktor, da Sie sie programmgesteuert hinzufügen. Wenn keine Konstruktoren von Ihnen hinzugefügt werden, sieht der vom Compiler generierte Standardkonstruktor so aus.

public Module()
{
   super();
}

Hinweis : Im Side-Default-Konstruktor wird auch ein super () - Aufruf hinzugefügt, um den Superklassenkonstruktor aufzurufen.

Zweck des Hinzufügens eines Standardkonstruktors:

Die Aufgabe des Konstruktors besteht darin, Instanzvariablen zu initialisieren. Wenn keine Instanzvariablen vorhanden sind, können Sie den Konstruktor aus Ihrer Klasse entfernen. Wenn Sie jedoch eine Klasse erben, ist es Ihre Klassenverantwortung, den Superklassenkonstruktor aufzurufen, um sicherzustellen, dass die Superklasse alle Instanzvariablen ordnungsgemäß initialisiert. 

Wenn also keine Konstruktoren vorhanden sind, fügt der Java-Compiler einen Standardkonstruktor hinzu und ruft den Superklassenkonstruktor auf.

2
user1923551

Ein Standardkonstruktor akzeptiert keine Argumente:

public class Student { 
    // default constructor
    public Student() {   

    }
}
0
user467871

Wenn wir einen Konstruktor nicht explizit für eine Klasse definieren, erstellt Java einen Standardkonstruktor für die Klasse. Es ist im Wesentlichen ein nicht parametrisierter Konstruktor, d. H. Er akzeptiert keine Argumente.

Der Standardkonstruktor hat die Aufgabe, den Superklassenkonstruktor aufzurufen und alle Instanzvariablen zu initialisieren. Wenn der Superklassenkonstruktor nicht vorhanden ist, werden die Instanzvariablen automatisch mit Null initialisiert. Dies dient also der Verwendung des Konstruktors, der den internen Zustand eines Objekts so initialisiert, dass der Code, der eine Instanz erstellt, ein vollständig initialisiertes, verwendbares Objekt hat. 

Wenn wir unseren eigenen Konstruktor für die Klasse definiert haben, wird der Standardkonstruktor nicht mehr verwendet. Also ist keiner von ihnen tatsächlich ein Standardkonstruktor.

0
uttsav