But d'un constructeur en Java?
Quel est le but d'un constructeur? J'ai appris Java à l'école et il me semble qu'un constructeur est en grande partie redondant dans ce que nous avons fait jusqu'à présent. Il reste à voir si un objectif est atteint, mais jusqu'à présent, cela ne semble pas avoir de sens. Par exemple, quelle est la différence entre les deux extraits de code suivants?
public class Program {
public constructor () {
function();
}
private void function () {
//do stuff
}
public static void main(String[] args) {
constructor a = new constructor();
}
}
Voici comment on nous a appris à faire les choses pour les devoirs, mais est-ce que les personnes ci-dessous ne feraient pas la même chose?
public class Program {
public static void main(String[] args) {
function();
}
private void function() {
//do stuff
}
}
Le but d’un constructeur m’échappe, mais là encore tout ce que nous avons fait jusqu’à présent a été extrêmement rudimentaire.
Les constructeurs sont utilisés pour initialiser les instances de vos classes. Vous utilisez un constructeur pour créer de nouveaux objets souvent avec des paramètres spécifiant l'état initial ou d'autres informations importantes sur l'objet
Extrait du tutoriel officiel sur Java :
Un la classe contient les constructeurs qui sont appelés pour créer des objets à partir du plan de classe. Les déclarations de constructeur ressemblent à des déclarations de méthodes, sauf qu'elles utilisent le nom de la classe et n'ont aucun type de retour. Par exemple, Bicycle a un constructeur:
public Bicycle(int startCadence, int startSpeed, int startGear) { gear = startGear; cadence = startCadence; speed = startSpeed; }Pour créer un nouvel objet Bicycle appelé
myBike, un constructeur est appelé par l'opérateur new:Bicycle myBike = nouveau vélo (30, 0, 8);
new Bicycle(30, 0, 8)crée un espace en mémoire pour l'objet et initialise ses champs.Bien que Bicycle n'ait qu'un seul constructeur, il peut en avoir d'autres, y compris un constructeur sans argument:
bicyclette publique () { vitesse = 1; cadence = 10; vitesse = 0; }
Bicycle yourBike = new Bicycle();appelle le constructeur sans argument pour créer un nouvel objet Bicycle appelé yourBike.
Un constructeur est fondamentalement une méthode que vous pouvez utiliser pour assurez-vous que les objets de votre classe sont nés valides . C'est la principale motivation d'un constructeur.
Supposons que votre classe ait un seul champ entier qui doit toujours être supérieur à zéro. Comment faites-vous cela d'une manière fiable?
public class C {
private int number;
public C(int number) {
setNumber(number);
}
public void setNumber(int number) {
if (number < 1) {
throws IllegalArgumentException("C cannot store anything smaller than 1");
}
this.number = number;
}
}
Dans le code ci-dessus, il peut sembler que vous fassiez quelque chose de redondant, mais en fait, vous vous assurez que le nombre est toujours valide, quoi qu'il en soit.
"initialiser les instances d'une classe" est ce que un constructeur fait, mais pas la raison pourquoi nous avons des constructeurs. La question concerne le but d'un constructeur. Vous pouvez également initialiser des instances d'une classe en externe, en utilisant c.setNumber(10) dans l'exemple ci-dessus. Un constructeur n'est donc pas le seul moyen d'initialiser des instances.
Le constructeur le fait mais d'une manière qui est sans danger . En d'autres termes, une classe à elle seule résout le problème de s'assurer que leurs objets sont toujours dans des états valides. Ne pas utiliser de constructeur laissera une telle validation au monde extérieur, ce qui est une mauvaise conception.
Voici un autre exemple:
public class Interval {
private long start;
private long end;
public Interval(long start, long end) {
changeInterval(start, end);
}
public void changeInterval(long start, long end) {
if (start >= end) {
throw new IllegalArgumentException("Invalid interval.");
}
this.start = start;
this.end = end;
}
public long duration() {
return end - start;
}
}
La classe Interval représente un intervalle de temps. Le temps est stocké en utilisant long. Cela n'a aucun sens d'avoir un intervalle qui se termine avant qu'il ne commence. En utilisant un constructeur comme celui ci-dessus, il est impossible d'avoir à tout moment dans le système une instance d'intervalle qui stocke un intervalle qui n'a pas de sens.
Comme indiqué dans LotusUNSW, answer Les constructeurs sont utilisés pour initialiser les instances d'une classe.
Exemple:
Disons que vous avez une classe Animal quelque chose comme
class Animal{
private String name;
private String type;
}
Voyons ce qui se passe lorsque vous essayez de créer une instance de la classe Animal, disons une Dog nommée Puppy. Maintenant, vous devez initialiser name = Puppy et type = Dog. Alors, comment pouvez-vous faire ça? Une façon de le faire est d'avoir un constructeur comme
Animal(String nameProvided, String typeProvided){
this.name = nameProvided;
this.type = typeProvided;
}
Désormais, lorsque vous créez un objet de classe Animal, le constructeur s'appelle Animal dog = new Animal("Puppy", "Dog"); et initialise le nom et le type aux valeurs que vous avez fournies, à savoir Puppy et Dog, respectivement.
Maintenant, vous pourriez demander si, si je ne fournissais pas un argument à mon constructeur, quelque chose comme:
Animal xyz = new Animal();
C'est un default Constructor qui initialise l'objet avec les valeurs par défaut, c'est-à-dire dans nos valeurs Animal de classe name et type correspondant à l'objet xyz serait name = null et type = null
Un constructeur initialise un objet lors de sa création. Il porte le même nom que sa classe et est syntaxiquement similaire à une méthode, mais les constructeurs n'ont pas de type de retour explicite .Généralement, nous utilisons constructor pour donner une valeur initiale aux variables d'instance définies par la classe ou pour effectuer tout autre démarrage procédures nécessaires pour faire un objet entièrement formé.
Voici un exemple de constructeur:
class queen(){
int beauty;
queen(){
beauty = 98;
}
}
class constructor demo{
public static void main(String[] args){
queen arth = new queen();
queen y = new queen();
System.out.println(arth.beauty+" "+y.beauty);
}
}
la sortie est:
98 98
Ici le constructeur est:
queen(){
beauty =98;
}
Passons maintenant au constructeur paramétré.
class queen(){
int beauty;
queen(int x){
beauty = x;
}
}
class constructor demo{
public static void main(String[] args){
queen arth = new queen(100);
queen y = new queen(98);
System.out.println(arth.beauty+" "+y.beauty);
}
}
la sortie est:
100 98
- Via un constructeur (avec des paramètres), vous pouvez «demander» à l'utilisateur de cette classe les dépendances requises.
- Il est utilisé pour initialiser les variables d'instance
- et de transmettre des arguments au constructeur d'une super classe (
super(...)), qui fait fondamentalement la même chose - Il peut initialiser des variables d’instance (finales) avec du code pouvant générer des exceptions, par opposition à instance initializer scopes
- On devrait not appeler aveuglément des méthodes depuis le constructeur, car l'initialisation risque de ne pas être terminée/suffisante dans la classe locale ou dérivée.
Un constructeur Java a le même nom que le nom de la classe à laquelle il appartient.
La syntaxe du constructeur n'inclut pas de type de retour, car les constructeurs ne renvoient jamais de valeur.
Le constructeur est toujours appelé lorsque l'objet est créé. exemple: - constructeur par défaut
class Student3{
int id;
String name;
void display(){System.out.println(id+" "+name);}
public static void main(String args[]){
Student3 s1=new Student3();
Student3 s2=new Student3();
s1.display();
s2.display();
}
}
Sortie:
0 null
0 null
Explication: Dans la classe ci-dessus, vous ne créez aucun constructeur. Le compilateur vous fournit donc un constructeur par défaut.Voici les valeurs 0 et null sont fournies par le constructeur par défaut.
Exemple de constructeur paramétré
Dans cet exemple, nous avons créé le constructeur de la classe Student qui a deux paramètres. Nous pouvons avoir n'importe quel nombre de paramètres dans le constructeur.
class Student4{
int id;
String name;
Student4(int i,String n){
id = i;
name = n;
}
void display(){System.out.println(id+" "+name);}
public static void main(String args[]){
Student4 s1 = new Student4(111,"Karan");
Student4 s2 = new Student4(222,"Aryan");
s1.display();
s2.display();
}
}
Sortie:
111 Karan
222 Aryan
Constructor sera utile pour empêcher les instances d'obtenir des valeurs irréelles. Pour un exemple, définissez une classe Personne avec une hauteur, un poids. Il ne peut y avoir de personne avec 0m et 0kg
Il est utilisé pour configurer le contenu et l'état de votre classe . S'il est vrai que vous pouvez créer un exemple plus simple avec la méthode principale, vous ne disposez que d'une seule méthode principale par application, de sorte qu'elle ne reste pas une approche judicieuse.
Considérez la méthode principale pour démarrer simplement votre programme et ne devriez pas savoir plus que comment le faire. Notez également que main () est statique et ne peut donc pas appeler des fonctions nécessitant une instance de classe et l’état associé. La méthode principale doit appeler new Program (). Function () et le constructeur du programme ne doit pas appeler function () à moins que cela ne soit nécessaire pour la configuration de la classe.
Le constructeur est essentiellement utilisé pour initialiser les variables au moment de la création de l'objet
La définition de classe définit l'API pour votre classe. En d'autres termes, il s'agit d'un plan qui définit le contrat qui existe entre la classe et ses clients - tout le code qui utilise cette classe. Le contrat indique quelles méthodes sont disponibles, comment les appeler et à quoi s'attendre en retour.
Mais la définition de classe est une spécification. Jusqu'à ce que vous ayez un objet de cette classe, le contrat n'est qu'un "morceau de papier". C'est ici qu'intervient le constructeur.
Un constructeur est le moyen de créer une instance de votre classe en créant un objet en mémoire et en lui renvoyant une référence. Quelque chose qui devrait se produire dans le constructeur est que l’objet est dans un état initial approprié pour que les opérations suivantes sur l’objet aient un sens.
Cet objet renvoyé par le constructeur va maintenant honorer le contrat spécifié dans la définition de classe et vous pouvez utiliser cet objet pour effectuer un travail réel.
Pense-y de cette façon. Si vous consultez un jour le site Web de Porsche, vous verrez ce qu’il peut faire: puissance, couple, etc. Mais ce n’est pas amusant tant que vous n’avez pas une vraie Porsche à conduire.
J'espère que cela pourra aider.
Je pensais qu'un constructeur pourrait fonctionner comme une base de données dans laquelle il ne définit que des variables et des méthodes pour les contrôler.
Ensuite, j'ai vu des objets qui utilisent des variables et des méthodes non définies dans son constructeur. Donc, la discussion qui me semble la plus logique est celle qui teste la validité des valeurs de variables, mais la classe peut créer des variables et des méthodes qui ne sont pas définies dans le constructeur - moins comme une base de données et plus comme une valve de surpression sur un Steam locomotive. Il ne contrôle pas les roues, etc.
Beaucoup moins d'une définition que je pensais.
Considérons que nous stockons les détails des étudiants de 3 étudiants. Ces 3 étudiants ont des valeurs différentes pour sno, sname et sage, mais ils appartiennent tous au même département CSE. Il est donc préférable d’initialiser la variable "dept" dans un constructeur afin que cette valeur puisse être prise par les 3 objets étudiant.
Pour bien comprendre, voir l'exemple simple ci-dessous:
class Student
{
int sno,sage;
String sname,dept;
Student()
{
dept="CSE";
}
public static void main(String a[])
{
Student s1=new Student();
s1.sno=101;
s1.sage=33;
s1.sname="John";
Student s2=new Student();
s2.sno=102;
s2.sage=99;
s2.sname="Peter";
Student s3=new Student();
s3.sno=102;
s3.sage=99;
s3.sname="Peter";
System.out.println("The details of student1 are");
System.out.println("The student no is:"+s1.sno);
System.out.println("The student age is:"+s1.sage);
System.out.println("The student name is:"+s1.sname);
System.out.println("The student dept is:"+s1.dept);
System.out.println("The details of student2 are");`enter code here`
System.out.println("The student no is:"+s2.sno);
System.out.println("The student age is:"+s2.sage);
System.out.println("The student name is:"+s2.sname);
System.out.println("The student dept is:"+s2.dept);
System.out.println("The details of student2 are");
System.out.println("The student no is:"+s3.sno);
System.out.println("The student age is:"+s3.sage);
System.out.println("The student name is:"+s3.sname);
System.out.println("The student dept is:"+s3.dept);
}
}
Sortie:
Les détails de student1 sont
Le numéro d'étudiant est: 101
L'âge de l'étudiant est: 33 ans
Le nom de l'étudiant est: John
Le département étudiant est: CSE
Les détails de student2 sont
Le numéro d'étudiant est: 102
L'âge d'étudiant est: 99
Le nom de l'étudiant est: Peter
Le département étudiant est: CSE
Les détails de student2 sont
Le numéro d'étudiant est: 102
L'âge d'étudiant est: 99
Le nom de l'étudiant est: Peter
Le département étudiant est: CSE
Eh bien, je vais d'abord raconter les erreurs dans deux extraits de code.
Premier extrait de code
public class Program
{
public constructor() // Error - Return type for the method is missing
{
function();
}
private void function()
{
//do stuff
}
public static void main(String[] args)
{
constructor a = new constructor(); // Error - constructor cannot be resolved to a type
}
}
Comme vous pouvez voir le code ci-dessus, le nom du constructeur n'est pas identique au nom de la classe. Dans la méthode main(), vous créez un objet à partir d'une méthode qui n'a aucun type de retour.
Deuxième extrait de code
public class Program
{
public static void main(String[] args)
{
function(); // Error - Cannot make a static reference to the non-static method function() from the type Program
}
private void function()
{
//do stuff
}
}
Maintenant, dans cet extrait de code, vous essayez de créer une référence statique à la méthode non statique function () à partir du type Program, ce qui n'est pas possible.
Donc, la solution possible est la suivante:
Premier extrait de code
public class Program
{
public Program()
{
function();
}
private void function()
{
//do stuff
}
public static void main(String[] args)
{
Program a = new Program();
a.function();
}
}
Deuxième extrait de code
public class Program
{
public static void main(String[] args)
{
Program a = new Program();
a.function();
}
private void function()
{
//do stuff
}
}
Enfin, la différence entre les extraits de code est que, dans le premier extrait de code, le nom de la classe n’est pas identique au nom de la classe.
Tandis que dans le deuxième extrait de code, aucun constructeur n'est défini.
Pendant ce temps, pour comprendre le but du constructeur, référez-vous aux ressources ci-dessous,
https://docs.Oracle.com/javase/7/docs/api/Java/lang/reflect/Constructor.html