Constructeur Java par défaut
Qu'est-ce qu'un constructeur par défaut? Pouvez-vous me dire lequel des constructeurs par défaut est ce qui le différencie des autres?
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;
}
Aucun d'eux. Si vous le définissez, ce n'est pas la valeur par défaut.
Le constructeur par défaut est le constructeur sans argument généré automatiquement à moins que vous ne définissiez un autre constructeur. Tous les champs non initialisés seront définis sur leurs valeurs par défaut. Pour votre exemple, cela ressemble à ceci en supposant que les types sont String, int et int et que la classe elle-même est publique:
public Module()
{
super();
this.name = null;
this.credits = 0;
this.hours = 0;
}
C'est exactement la même chose que
public Module()
{}
Et exactement la même chose que de ne pas avoir de constructeur du tout. Toutefois, si vous définissez au moins un constructeur, le constructeur par défaut n'est pas généré.
Référence: Spécification du langage Java
Si une classe ne contient aucune déclaration de constructeur, un constructeur par défaut ne contenant aucun paramètre formel et aucune clause throws est déclaré implicitement.
Clarification
Techniquement, ce n'est pas le constructeur (par défaut ou autre) qui initialise par défaut les champs. Cependant, je laisse la réponse parce que
- la question s'est trompée, et
- le constructeur a exactement le même effet, qu’ils soient inclus ou non.
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: Except call 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, votre classe n'a donc pas de constructeur par défaut.
Per Spécification du langage Java, troisième édition:
8.8.9 Constructeur par défaut
Si une classe ne contient pas de constructeur déclarations, puis une valeur par défaut constructeur qui ne prend aucun paramètre est automatiquement fourni ...
Salut. Selon mes connaissances, laissez-moi clarifier le concept de constructeur par défaut:
Le compilateur fournit automatiquement un constructeur sans argument, par défaut pour toute classe sans constructeurs. Ce constructeur par défaut appellera le constructeur sans argument de la super-classe. Dans cette situation, le le compilateur se plaindra si la super-classe n'a pas de non-argument constructeur alors vous devez vérifier que c'est le cas. Si votre classe n'a pas superclasse explicite, alors il a une superclasse implicite d’Object, qui a un constructeur sans argument.
J'ai lu ces informations dans Tutoriels Java .
Java fournit un constructeur par défaut qui ne prend aucun argument et ne réalise aucune action spéciale ni initialisation, quand aucun constructeur explicite n'est fourni.
La seule action entreprise par le constructeur implicite par défaut consiste à appeler le constructeur de la superclasse à l'aide de l'appel super (). Les arguments de constructeur vous fournissent un moyen de fournir des paramètres pour l'initialisation d'un objet.
Vous trouverez ci-dessous un exemple de classe de cube contenant 2 constructeurs. (un constructeur par défaut et un 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é et s'appelle constructeur par défaut.
Si vous définissez un constructeur identique à celui qui serait placé si vous n'en fournissez aucun, il est généralement appelé constructeur sans arguments. Une convention, bien que certains programmeurs préfèrent l'appeler explicitement, constructeur d'arguments comme constructeur par défaut. Mais si nous allons en nommant si nous définissons explicitement un, cela ne le rend pas par défaut.
Selon les docs
Si une classe ne contient aucune déclaration de constructeur, un constructeur par défaut ne contenant aucun paramètre formel et aucune clause throws est déclaré implicitement.
Exemple
public class Dog
{
}
sera automatiquement modifié (en ajoutant le constructeur par défaut) comme suit
public class Dog{
public Dog() {
}
}
et quand vous créez c'est objet
Dog myDog = new Dog();
ce constructeur par défaut est appelé.
constructeur par défaut fait référence à un constructeur généré automatiquement par le compilateur en l'absence de constructeurs définis 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 ni 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
Si une classe n'a aucun constructeur fourni par le programmeur, le compilateur Java ajoutera un constructeur par défaut avec des paramètres out qui appellera le constructeur de la super classe en interne avec l'appel super (). Ceci est appelé constructeur par défaut.
Dans votre cas, il n'y a pas de constructeur par défaut car vous les ajoutez par programme . Si aucun constructeur n'est ajouté par vous, le constructeur par défaut généré par le compilateur ressemblera à ceci.
public Module()
{
super();
}
Note : Dans le constructeur par défaut, il sera également ajouté un appel super (), pour appeler le constructeur de la super classe.
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. Toutefois, lorsque vous héritez d'une classe, il vous incombe d'appeler le constructeur de la super classe afin de vous assurer que cette dernière initialise correctement toutes ses variables d'instance.
C'est pourquoi s'il n'y a pas de constructeurs, le compilateur Java ajoute un constructeur par défaut et appelle le constructeur de la super classe.
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, Java crée un constructeur par défaut pour la classe. Il s’agit essentiellement d’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 la super classe et à initialiser toutes les variables d'instance. Si le constructeur de la super classe n'est pas présent, il initialise automatiquement les variables d'instance à zéro. Cela a donc pour but d'utiliser constructeur, qui consiste à initialiser l'état interne d'un objet afin que le code créant une instance ait un objet utilisable complètement initialisé.
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 réalité un constructeur par défaut.