Constructeur par défaut Java

Un constructeur par défaut est créé si vous ne définissez aucun constructeur dans votre classe. C'est simplement un constructeur sans argument qui ne fait rien. Edit: Sauf appel super ()

public Module(){
}

Un constructeur par défaut est automatiquement généré par le compilateur si vous ne définissez pas explicitement au moins un constructeur dans votre classe. Vous en avez défini deux, donc votre classe n'a pas de constructeur par défaut.

Par La Spécification du langage Java Troisième édition :

8.8.9 Constructeur Par Défaut

Si une classe ne contient aucun constructeur déclarations, alors par défaut constructeur qui ne prend aucun paramètre est automatiquement fourni...

Salut. Selon ma connaissance, permettez-moi de clarifier le concept de constructeur par défaut:

Le compilateur fournit automatiquement un constructeur par défaut sans argument pour toute classe sans constructeurs. Ce constructeur par défaut appellera le constructeur sans argument de la superclasse. Dans cette situation, l' le compilateur se plaindra si la superclasse n'a pas de no-argument constructeur vous devez donc vérifier que c'est le cas. Si votre classe n'a pas de superclasse explicite, alors il a un superclasse implicite d'objet, qui dispose d'un constructeur sans argument.

J'ai lu ces informations dans les Tutoriels Java.

Java fournit un constructeur par défaut qui ne prend aucun argument et n'effectue aucune action ou initialisation spéciale, lorsqu'aucun constructeur explicite n'est fourni.

La seule action effectuée par le constructeur implicite par défaut est d'appeler le constructeur de superclasse en utilisant l'appel super (). Arguments du constructeur de vous fournir un moyen de fournir des paramètres pour l'initialisation d'un objet.

Voici un exemple de classe de cube contenant 2 constructeurs. (un défaut et une constructeur paramétré).

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

La terminologie générale est que si vous ne fournissez aucun constructeur dans votre objet, un constructeur sans argument est automatiquement placé, appelé constructeur par défaut.

Si vous définissez un constructeur identique à celui qui serait placé si vous n'en fournissez pas, il est généralement appelé constructeur sans arguments.Juste une convention bien que certains programmeurs préfèrent appeler ce constructeur explicitement défini no arguments en tant que constructeur par défaut. Mais si nous allons en nommant si nous définissons explicitement un qu'il ne le rend pas par défaut.

, Comme par le docs

Si une classe ne contient aucune déclaration de constructeur, alors un constructeur par défaut sans paramètres formels et sans clause throws est implicitement déclaré.

Exemple

public class Dog
{
}

Sera automatiquement modifié (en ajoutant le constructeur par défaut) comme suit

public class Dog{
    public Dog() {

    }
} 

Et lorsque vous créez son objet

 Dog myDog = new Dog();

Ce constructeur par défaut est invoqué.

Si une classe n'a pas de constructeur fourni par le programmeur, alors le compilateur java ajoutera un constructeur par défaut avec les paramètres out qui appellera le constructeur super class en interne avec l'appel super (). Ceci est appelé en tant que constructeur par défaut.

Dans votre cas, il n'y a pas de constructeur par défaut car vous les ajoutez par programme. S'il n'y a pas de constructeurs ajoutés par vous, alors le constructeur par défaut généré par le compilateur ressemblera à ceci.

public Module()
{
   super();
}

Note : Dans le côté constructeur par défaut, il ajoutera l'appel super () également, pour appeler le constructeur de classe super.

But de l'ajout du constructeur par défaut:

Le devoir du constructeur est d'initialiser les variables d'instance, s'il n'y a pas de variables d'instance, vous pouvez choisir de supprimer le constructeur de votre classe. Mais lorsque vous héritez d'une classe, il est de votre responsabilité d'appeler super class constructor pour vous assurer que super class initialise correctement toutes ses variables d'instance.

C'est pourquoi s'il n'y a pas de constructeurs, le compilateur java ajoutera un constructeur par défaut et appellera super class constructor.

Constructeur par défaut fait référence à un constructeur qui est généré automatiquement par le compilateur en l'absence de tout constructeur défini par le programmeur.

S'il n'y a pas de constructeur fourni par le programmeur, le compilateur déclare implicitement un constructeur par défaut qui appelle super(), n'a pas de clause throws ainsi que pas de paramètres formels.

Par exemple

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

Un constructeur par défaut ne prend aucun argument:

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

    }
}

Lorsque nous ne définissons pas explicitement un constructeur pour une classe, alors java crée un constructeur par défaut pour la classe. C'est essentiellement un constructeur non paramétré, c'est-à-dire qu'il n'accepte aucun argument.

Le travail du constructeur par défaut consiste à appeler le constructeur de super classe et à initialiser toutes les variables d'instance. Si le constructeur de super classe n'est pas présent, il initialise automatiquement les variables d'instance à zéro. Donc, cela sert à utiliser le constructeur, qui est d'initialiser l'état interne d'un objet afin que le code créant une instance ait un objet entièrement initialisé et utilisable.

Une fois que nous avons défini notre propre constructeur pour la classe, le constructeur par défaut n'est plus utilisé. Donc, aucun d'eux n'est en fait un constructeur par défaut.

J'espère que vous avez obtenu votre réponse concernant le constructeur par défaut. Mais je donne ci-dessous des déclarations pour corriger les commentaires donnés.

• Java n'initialise aucune variable locale à une valeur par défaut. Si si vous créez un objet d'une classe il appellera default constructeur et fournir des valeurs par défaut à l'objet.

• Constructeur par Défaut fournit les valeurs par défaut de l'objet comme 0, null etc. en fonction de la type.

Veuillez vous référer au lien ci-dessous pour plus de détails.

Https://www.javatpoint.com/constructor