Un constructeur est une structure similaire à une méthode dont le but est de créer une instance d’une classe. Caractéristiques du concepteur :

• Le nom du constructeur doit correspondre au nom de la classe (par convention, la première lettre est en majuscule, généralement un nom) ;
• Il existe un constructeur dans n'importe quelle classe. Même si vous n'en écrivez pas, le compilateur Java créera un constructeur par défaut, qui sera vide et ne fera rien d'autre que d'appeler le constructeur de la superclasse.
• Un constructeur est similaire à une méthode, mais ce n’est pas une méthode, il n’est même pas considéré comme un membre de la classe. Par conséquent, il ne peut pas être hérité ou remplacé dans une sous-classe ;
• Les constructeurs ne sont pas hérités ;
• Il peut y avoir plusieurs constructeurs dans une classe. Dans ce cas, les constructeurs sont dits surchargés ;
• Si une classe ne définit pas de constructeur, le compilateur ajoute automatiquement un constructeur sans paramètre au code ;
• Un constructeur n'a pas de type de retour, il ne peut même pas être un type void ; si un type void est renvoyé, alors ce n'est plus un constructeur mais une méthode, malgré la coïncidence avec le nom de la classe.
• Une instruction return est autorisée dans un constructeur, mais uniquement vide, sans aucune valeur de retour ;
• Le constructeur permet l'utilisation de modificateurs d'accès ; vous pouvez définir l'un des modificateurs : public, protégé, privé ou sans modificateur.
• Un constructeur ne peut pas avoir de modificateurs abstraits, finaux, natifs, statiques ou synchronisés ;
• Le mot clé this fait référence à un autre constructeur de la même classe. S'il est utilisé, son appel doit être la première ligne du constructeur ;
• Le super mot-clé appelle le constructeur de la classe parent. Si elle est utilisée, la référence à celui-ci doit être la première ligne du constructeur ;
• Si le constructeur n'appelle pas le super constructeur de la classe ancêtre (avec ou sans arguments), le compilateur ajoute automatiquement du code pour appeler le constructeur de la classe ancêtre sans arguments ;

Constructeur par défaut

Il existe un constructeur dans n'importe quelle classe. Même si vous n'en écrivez pas, le compilateur Java créera un constructeur par défaut. Ce constructeur est vide et ne fait rien d'autre que d'appeler le constructeur de la superclasse. Ceux. si vous écrivez : public class Exemple ( ) alors cela équivaut à écrire : public class Exemple ( Exemple () ( super ; ) ) Dans ce cas, la classe ancêtre n'est pas explicitement spécifiée, et par défaut, toutes les classes Java héritent de l'Objet classe, donc le constructeur de la classe Object est appelé. Si une classe définit un constructeur avec des paramètres, mais qu'il n'y a pas de constructeur surchargé sans paramètres, alors appeler le constructeur sans paramètres est une erreur. Cependant, en Java depuis la version 1.5, il est possible d'utiliser des constructeurs avec des arguments de longueur variable. Et s'il existe un constructeur qui a un argument de longueur variable, alors appeler le constructeur par défaut ne sera pas une erreur. Ce ne sera pas le cas car l’argument de longueur variable peut être vide. Par exemple, l'exemple suivant ne sera pas compilé, mais si vous décommentez le constructeur avec un argument de longueur variable, la compilation et l'exécution réussiront et donneront la ligne de code DefaultDemo dd = new DefaultDemo() ; Le constructeur DefaultDemo(int ... v) sera appelé. Naturellement, dans ce cas, il est nécessaire d'utiliser JSDK 1.5. Fichier DefaultDemo.java classe DefaultDemo ( DefaultDemo (String s) ( System. out. print ( "DefaultDemo(String)" ) ; ) /* DefaultDemo(int ... v) ( System.out.println("DefaultDemo(int ...)"); ) */ public static void main (String args) ( DefaultDemo dd = new DefaultDemo () ; ) ) Le résultat de la sortie du programme lorsque le constructeur n'est pas commenté : DefaultDemo (int . . . ) Cependant, dans le cas courant où aucun constructeur n'est défini dans la classe, l'appel d'un constructeur par défaut (sans paramètres) sera nécessaire car la substitution du constructeur par défaut se produit automatiquement.

Lors de la création d'un objet, les actions suivantes sont effectuées séquentiellement :

• La classe d'objet est recherchée parmi les classes déjà utilisées dans le programme. S'il n'y est pas, il est recherché dans tous les catalogues et bibliothèques disponibles pour le programme. Une fois qu'une classe est découverte dans un répertoire ou une bibliothèque, les champs statiques de la classe sont créés et initialisés. Ceux. Pour chaque classe, les champs statiques ne sont initialisés qu'une seule fois.
• La mémoire est allouée à l'objet.
• Les champs de classe sont en cours d'initialisation.
• Le constructeur de classe s'exécute.
• Un lien vers l'objet créé et initialisé est formé. Cette référence est la valeur de l'expression qui crée l'objet. Un objet peut également être créé en appelant la méthode newInstance() de la classe java.lang.Class. Dans ce cas, un constructeur sans liste de paramètres est utilisé.

Surcharge des constructeurs

Les constructeurs d’une même classe peuvent avoir le même nom et une signature différente. Cette propriété est appelée combinaison ou surcharge. Si une classe possède plusieurs constructeurs, une surcharge de constructeur est présente.

Constructeurs paramétrés

La signature d'un constructeur est le nombre et les types de paramètres, ainsi que l'ordre de leurs types dans la liste des paramètres du constructeur. Le type de retour n'est pas pris en compte. Le constructeur ne renvoie aucun paramètre. Cette déclaration explique, dans un sens, comment Java fait la distinction entre des constructeurs ou des méthodes surchargés. Java distingue les méthodes surchargées non pas par leur type de retour, mais par le nombre, les types et la séquence de types de paramètres d'entrée. Un constructeur ne peut même pas renvoyer un type void, sinon il se transformera en une méthode régulière, même si elle ressemble au nom de la classe. L’exemple suivant le démontre. Fichier VoidDemo.java classe VoidDemo ( /** * Ceci est un constructeur */ VoidDemo () ( System. out. println ( "Constructeur" ) ; ) void VoidDemo () ( System. out. println ( "Méthode" ) ; ) public static void main (String s ) ( VoidDemo m = new VoidDemo () ; ) ) En conséquence, le programme affichera : Constructeur Cela prouve une fois de plus qu'un constructeur est une méthode sans paramètres de retour. Cependant, vous pouvez spécifier l'un des trois modificateurs pour un constructeur : public, privé ou protégé. Et l'exemple ressemblera désormais à ceci : Fichier VoidDemo2.java classe VoidDemo2 ( /** * Ceci est un constructeur */ public VoidDemo2 () ( System. out. println ( "Constructeur" ) ; ) /** * Et c'est déjà une méthode régulière, même malgré la similitude avec le * nom de la classe, puisqu'elle a un type de retour vide */ private void VoidDemo2 () ( System. out. println ( "Method" ) ; ) public static void main (String s ) ( VoidDemo2 m = new VoidDemo2 () ; ) ) Il est permis d'écrire une instruction return dans le constructeur, mais seulement vide, sans aucune valeur de retour. Fichier ReturnDemo.java classe ReturnDemo ( /** * Le constructeur permet l'utilisation de l'opérateur * return sans paramètres. */ public ReturnDemo () ( System. out. println ( "Constructeur" ) ; return ; ) public static void main (String s ) ( ReturnDemo r = new ReturnDemo () ; ) )

Constructeurs paramétrés avec des arguments de longueur variable

Java SDK 1.5 a introduit un outil tant attendu : des arguments de longueur variable pour les constructeurs et les méthodes. Auparavant, un nombre variable de documents étaient traités de deux manières peu pratiques. Le premier d’entre eux a été conçu pour garantir que le nombre maximum d’arguments soit limité à un petit nombre et connu à l’avance. Dans ce cas, il était possible de créer des versions surchargées de la méthode, une pour chaque version de la liste d'arguments passée à la méthode. La deuxième méthode est conçue pour quelque chose d'inconnu à l'avance et un grand nombre d'arguments. Dans ce cas, les arguments étaient placés dans un tableau, et ce tableau était passé à la méthode. Les arguments de longueur variable sont le plus souvent impliqués dans des manipulations ultérieures avec des initialisations variables. Il est pratique de remplacer l’absence de certains arguments attendus du constructeur ou de la méthode par des valeurs par défaut. L'argument de longueur variable est un tableau et est traité comme un tableau. Par exemple, le constructeur d'une classe Checking avec un nombre variable d'arguments ressemblerait à ceci : class Checking ( public Checking (int . . . n) ( ) ) La combinaison de caractères... indique au compilateur qu'un nombre variable d'arguments seront utilisés, et que ces arguments seront stockés dans un tableau dont la valeur de référence est contenue dans la variable n. Le constructeur peut être appelé avec un nombre différent d'arguments, y compris aucun argument. Les arguments sont automatiquement placés dans un tableau et passés par n. S'il n'y a aucun argument, la longueur du tableau est 0. La liste des paramètres, ainsi que les arguments de longueur variable, peuvent également inclure des paramètres obligatoires. Dans ce cas, un paramètre contenant un nombre variable d'arguments doit être le dernier de la liste des paramètres. Par exemple : class Checking ( public Checking (String s, int . . . n) ( ) ) Une limitation très évidente concerne le nombre de paramètres de longueur variable. Il ne doit y avoir qu'un seul paramètre de longueur variable dans la liste des paramètres. Étant donné deux paramètres de longueur variable, il est impossible pour le compilateur de déterminer où se termine un paramètre et où commence l’autre. Par exemple : class Checking ( public Checking (String s, int . . n, double . . . d) //ERROR! ( ) ) File Checking.java Par exemple, il existe des équipements capables de reconnaître les plaques d'immatriculation des voitures et de mémoriser les numéros. de carrés de terrain où visitaient chacune des voitures en une journée. Il est nécessaire de sélectionner parmi la masse totale des voitures enregistrées celles qui ont visité pendant la journée deux places données, par exemple 22 et 15, selon la carte de la zone. Il est tout à fait naturel qu'une voiture puisse visiter plusieurs places au cours de la journée, voire une seule. Bien évidemment, le nombre de places visitées est limité par la vitesse physique de la voiture. Créons un petit programme où le constructeur de classe prendra comme arguments le numéro de voiture comme paramètre obligatoire et le nombre de places visitées de la zone, dont le nombre peut être variable. Le constructeur vérifiera si une voiture est apparue sur deux cases ; si c'est le cas, il affichera son numéro sur l'écran.

Passer des paramètres au constructeur

Il existe principalement deux types de paramètres dans les langages de programmation :

• types de base (primitifs) ;
• références à des objets.

Le terme appel par valeur signifie que le constructeur reçoit la valeur qui lui est transmise par le module appelant. En revanche, l'appel par référence signifie que le constructeur reçoit l'adresse de la variable de l'appelant. Java utilise uniquement l'appel par valeur. Par valeur de paramètre et par valeur de lien de paramètre. Java n'utilise pas l'appel par référence pour les objets (bien que de nombreux programmeurs et auteurs de certains livres le prétendent). Les paramètres lors du passage d'objets en Java sont implémentés pas du lien, UN par valeur de référence d'objet! Dans les deux cas, le constructeur reçoit des copies des valeurs de tous les paramètres. Le constructeur n'a rien à faire avec ses paramètres d'entrée :

• le constructeur ne peut pas modifier les valeurs des paramètres d'entrée des types principaux (primitifs) ;
• le constructeur ne peut pas modifier les références des paramètres d'entrée ;
• le constructeur ne peut pas réaffecter les références de paramètres d'entrée à de nouveaux objets.

Le constructeur peut faire avec ses paramètres d'entrée :

• changer l'état de l'objet passé en paramètre d'entrée.

L'exemple suivant prouve qu'en Java, les paramètres d'entrée d'un constructeur sont transmis par valeur de référence d'objet. Cet exemple reflète également que le constructeur ne peut pas modifier les références des paramètres d'entrée, mais modifie en fait les références des copies des paramètres d'entrée. Fichier Empoyee.java classe Employé ( Employé (String x, String y) ( String temp = x; x = y; y = temp; ) public static void main ( String args ) ( String name1 = new String ( "Alice" ) ; String nom2 = new String ("Mary" ) ; Employee a = new Employee (name1, name2) ; System.out.println ("name1=" + name1) ; System.out.println ("name2=" + name2) ; ) ) Le résultat du programme est : name1= Alice name2= Mary Si Java utilisait l'appel par référence pour passer des objets en tant que paramètres, le constructeur échangerait name1 et name2 dans cet exemple. Le constructeur n'échangera pas réellement les références d'objet stockées dans les variables nom1 et nom2. Cela suggère que les paramètres du constructeur sont initialisés avec des copies de ces références. Ensuite, le constructeur échange les copies. Une fois le constructeur terminé, les variables x et y sont détruites et les variables d'origine nom1 et nom2 continuent de faire référence aux objets précédents.

Modification des paramètres passés au constructeur.

Le constructeur ne peut pas modifier les paramètres passés des types de base. Cependant, le constructeur peut modifier l'état de l'objet passé en paramètre. Par exemple, considérons le programme suivant : Fichier Salary1.java class Salary1 ( Salary1 (int x) ( x = x * 3 ; System. out. println ( "x=" + x) ; ) public static void main ( String args ) ( valeur int = 1000 ; Salaire1 s1 = nouveau Salaire1 (valeur) ; System. out. println ("value=" + valeur) ; ) ) Le résultat du programme est : x= 3000 value= 1000 Évidemment, cette méthode ne modifiera pas le paramètre de type principal. Ainsi, après avoir appelé le constructeur, la valeur de la variable reste égale à 1000. Essentiellement, trois choses se produisent :

1. La variable x est initialisée avec une copie du paramètre value (c'est-à-dire le nombre 1000).
2. La valeur de la variable x est triplée : elle est désormais égale à 3000. Cependant, la variable value reste définie sur 1000 .
3. Le constructeur se termine et la variable x n'est plus utilisée.

Dans l'exemple suivant, le salaire de l'employé est triplé avec succès car la valeur d'une référence d'objet est transmise en tant que paramètre à la méthode. Fichier Salaire2.java classe Salaire2 ( valeur int = 1000 ; Salaire2 () ( ) Salaire2 (Salaire2 x) ( x. valeur = x. valeur * 3 ; ) public static void main (String args) ( Salaire2 s1 = nouveau Salaire2 () ; Salaire2 s2 = nouveau Salaire2 (s1) ; System. out. println ("s1.value="+ s1. valeur); Système. dehors. println("s2.value="+ s2. valeur); ) ) Le résultat du programme est : s1. valeur = 3000 s2. value= 1000 La valeur de la référence de l'objet est utilisée comme paramètre. Lors de l'exécution de la ligne Salary2 s2 = new Salary2(s1) ; le constructeur de Salary2(Salary x) recevra la valeur de la référence d'objet de la variable s1 , et le constructeur triplera en fait le salaire pour s1.value , puisque même la copie (Salary x) créée à l'intérieur du constructeur pointe vers le objet de la variable s1 .

Constructeurs paramétrés par des primitives.

Si les paramètres du constructeur surchargé utilisent une primitive qui peut être restreinte (par exemple int<- double), то вызов метода со суженным значением возможен, несмотря на то, что метода, перегруженного с таким параметром нет. Например: Файл Primitive.java class Primitive { Primitive (double d) { d = d + 10 ; System. out. println (!}"d=" + d) ; } public static void main (String args ) { int i = 20 ; Primitive s1 = new Primitive (i) ; } } Le résultat du programme est : d= 30.0 Malgré le fait que la classe Primitive n'a pas de constructeur ayant un paramètre de type int , un constructeur avec un paramètre d'entrée de double fonctionnera. Avant que le constructeur ne soit appelé, la variable i sera développée du type int au type double . L'option inverse, lorsque la variable i serait de type double et que le constructeur n'aurait qu'un paramètre int, conduirait dans cette situation à une erreur de compilation.

Appel du constructeur et du nouvel opérateur

Le constructeur est toujours appelé avec l'opérateur new. Lorsqu'un constructeur est appelé avec l'opérateur new, le constructeur génère toujours une référence à un nouvel objet. Il est impossible de forcer le constructeur à former une référence à un objet déjà existant au lieu d'une référence à un nouvel objet, sauf en substituant l'objet en cours de désérialisation. Et avec l'opérateur new, au lieu d'une référence à un nouvel objet, il est impossible de former une référence à un objet déjà existant. Par exemple : Fichier Salary3.java class Salary3 ( valeur int = 1000 ; Salary3 () ( ) Salary3 (Salary3 x) ( x. value = x. value * 3 ; ) public static void main (String args) ( Salary3 s1 = new Salary3 () ; System. out. println ("Première création d'objet : " + s1. valeur) ; Salary3 s2 = nouveau Salary3 (s1) ; System. out. println (" Deuxième création d'objet : " + s2. valeur) ; Système . out. println (+ s1. value) ; Salary3 s3 = new Salary3 (s1) ; System. out. println ("Troisième création d'objet : " + s3. value) ; System. out. println ( "Que s'est-il passé avec le premier objet ? :"+ s1. valeur); ) ) Le résultat du programme est : Création du premier objet : 1000 Création du deuxième objet : 1000 Que s'est-il passé avec le premier objet ? : 3000 Création du troisième objet : 1000 Que s'est-il passé avec le premier objet ? : 9000 Tout d'abord, en utilisant la ligne Salary3 s1 = new Salary3() ; un nouvel objet est créé. Ensuite, si vous utilisez la ligne Salary3 s2 = new Salary3(s1) ; ou les lignes Salary3 s3 = new Salary3(s1) ; il serait possible de créer une référence à un objet déjà existant, alors s1.value s2.value et s3.value stockeraient la même valeur 1000 . En fait, dans la ligne Salary3 s2 = new Salary3(s1) ; un nouvel objet sera créé pour la variable s2 et l'état de l'objet pour la variable s1 changera en passant sa valeur de référence à l'objet dans le paramètre constructeur. Cela peut être vérifié par les résultats de sortie. Et lors de l'exécution de la ligne Salary3 s3 = new Salary3(s1) ; un NOUVEL objet sera créé pour la variable s3 et l'état de l'objet pour la variable s1 changera à nouveau.

Constructeurs et blocs d'initialisation, séquence d'actions lors de l'appel d'un constructeur

La section Création d'un objet et des constructeurs répertorie les actions générales effectuées lors de la création d'un objet. Parmi eux se trouvent les processus d'initialisation des champs de classe et d'élaboration du constructeur de classe, qui à leur tour ont également un ordre interne :

1. Tous les champs de données sont initialisés à leurs valeurs par défaut (0, faux ou nul).
2. Tous les initialiseurs de champ et blocs d'initialisation sont exécutés dans l'ordre dans lequel ils sont répertoriés dans la déclaration de classe.
3. Si un autre constructeur est appelé sur la première ligne d'un constructeur, alors le constructeur appelé est exécuté.
4. Le corps du constructeur est exécuté.

Le constructeur est lié à l'initialisation car en Java il existe trois manières d'initialiser un champ dans une classe :

• attribuer une valeur dans la déclaration ;
• attribuer des valeurs dans le bloc d'initialisation ;
• définir sa valeur dans le constructeur.

Naturellement, vous devez organiser le code d’initialisation de manière à ce qu’il soit facile à comprendre. La classe suivante est donnée à titre d'exemple : class Initialization ( int i; short z = 10 ; static int x; static float y; static ( x = 2000 ; y = 3.141 ; ) Initialization () ( System. out. println ( " i= " + i) ; System. out. println ("z=" + z) ; z = 20 ; System. out. println ("z=" + z) ; ) ) Dans l'exemple ci-dessus, les variables sont initialisées dans l'ordre suivant : d'abord Les variables statiques x et y sont initialisées aux valeurs par défaut. Ensuite, le bloc d'initialisation statique est exécuté. Ensuite, la variable i est initialisée à la valeur par défaut et la variable z est initialisée. Ensuite, le designer se met au travail. L’appel des constructeurs de classe ne doit pas dépendre de l’ordre dans lequel les champs sont déclarés. Cela peut conduire à des erreurs.

Constructeurs et héritage

Les constructeurs ne sont pas hérités. Par exemple : public class Exemple ( Exemple () ( ) public void sayHi () ( system. out. println ( "Hi" ) ; ) ) public class SubClass extends Exemple ( ) La classe SubClass hérite automatiquement de la méthode sayHi() définie dans la classe parent. Dans le même temps, le constructeur Sample() de la classe parent n'est pas hérité par sa sous-classe descendante.

Le mot clé this dans les constructeurs

Les constructeurs l'utilisent pour faire référence à un autre constructeur de la même classe, mais avec une liste de paramètres différente. Si le constructeur utilise le mot clé this, il doit être sur la première ligne ; ignorer cette règle entraînera une erreur du compilateur. Par exemple : File ThisDemo.java public class ThisDemo ( String name; ThisDemo (String s) ( name = s; System. out. println (name) ; ) ThisDemo () ( this ("John" ) ; ) public static void main (String args) ( ThisDemo td1 = new ThisDemo ( "Mary" ) ; ThisDemo td2 = new ThisDemo () ; ) ) Le résultat du programme est : Mary John Cet exemple a deux constructeurs. Le premier reçoit un argument de chaîne. Le second ne reçoit aucun argument, il appelle simplement le premier constructeur en utilisant le nom par défaut "John". Ainsi, vous pouvez utiliser des constructeurs pour initialiser les valeurs des champs de manière explicite et par défaut, ce qui est souvent nécessaire dans les programmes.

Le super mot-clé dans les constructeurs

Les constructeurs utilisent super pour appeler le constructeur de la superclasse. Si le constructeur utilise super , alors cet appel doit être sur la première ligne, sinon le compilateur générera une erreur. Voici un exemple : Fichier SuperClassDemo.java public class SuperClassDemo ( SuperClassDemo () ( ) ) class Child extends SuperClassDemo ( Child () ( super () ; ) ) Dans cet exemple simple, le constructeur Child() contient un appel à super( ) qui crée une classe d'instance SuperClassDemo, en plus de la classe Child. Étant donné que super doit être la première instruction exécutée dans le constructeur d'une sous-classe, cet ordre est toujours le même et ne dépend pas de l'utilisation ou non de super(). S'il n'est pas utilisé, alors le constructeur par défaut (sans paramètres) de chaque superclasse, en commençant par la classe de base, sera exécuté en premier. Le programme suivant montre quand les constructeurs sont exécutés. Fichier Call.java //Créer la superclasse A classe A ( A () ( System. out. println ( "À l'intérieur d'un constructeur." ) ; ) ) //Créer une sous-classe B qui étend la classe A la classe B étend A ( B () ( System. out. println ( "À l'intérieur du constructeur B." ) ; ) ) //Créer une classe (C) étendant la classe B la classe C étend B ( C () ( System. out. println ( "À l'intérieur du constructeur C." ) ; ) ) appel de classe ( public static void main (String args ) ( C c = new C () ; ) ) Résultat de ce programme :À l'intérieur d'un constructeur. Constructeur intérieur B. Constructeur intérieur C. Les constructeurs sont appelés par ordre de subordination de classe. Cela a du sens. Étant donné que la superclasse n’a connaissance d’aucune sous-classe, toute initialisation qu’elle doit effectuer est distincte. Si possible, il doit précéder toute initialisation effectuée par la sous-classe. C'est pourquoi cela devrait être fait en premier.

Constructeurs personnalisables

Le mécanisme d'identification de type au moment de l'exécution est l'un des principes fondamentaux puissants du langage Java qui implémente le polymorphisme. Cependant, un tel mécanisme ne protège pas le développeur contre la conversion de type incompatible dans certains cas. Le cas le plus courant est la manipulation d'un groupe d'objets dont les différents types sont inconnus à l'avance et déterminés à l'exécution. Étant donné que les erreurs associées à une incompatibilité de type ne peuvent apparaître qu'au stade de l'exécution, elles sont difficiles à trouver et à éliminer. L'introduction de types personnalisés dans Java 2 5.0 déplace certaines de ces erreurs du moment de l'exécution vers le moment de la compilation et fournit une partie de la sécurité des types manquante. Il n'est pas nécessaire de procéder à un transtypage de type explicite lors du passage d'un type Object à un type concret. Il convient de garder à l’esprit que les outils de personnalisation de type fonctionnent uniquement avec des objets et ne s’appliquent pas aux types de données primitifs situés en dehors de l’arborescence d’héritage de classe. Avec les types personnalisés, toutes les conversions sont effectuées automatiquement et en coulisses. Cela vous permet de vous protéger contre les incompatibilités de types et de réutiliser le code beaucoup plus souvent. Les types personnalisés peuvent être utilisés dans les constructeurs. Les constructeurs peuvent être personnalisés même si leur classe n'est pas un type personnalisé. Par exemple : class GenConstructor (private double val ;< T extends Number >GenConstructor (T arg) ( val = arg. doubleValue () ; ) void printValue () ( System. out. println ("val: " + val) ; ) ) class GenConstructorDemo ( public static void main (String args) ( GenConstructor gc1 = new GenConstructor(100); GenConstructor gc2 = new GenConstructor(123.5F); gc1. printValue(); gc2. printValue(); )) Parce que le constructeur GenConstructor spécifie un paramètre de type personnalisé qui doit être une classe dérivée de la classe Number , il peut appeler de n'importe quel

Un constructeur est une méthode spéciale appelée lors de la création d’un nouvel objet. Il n'est pas toujours pratique d'initialiser toutes les variables d'une classe lors de la création de son instance. Parfois, il est plus facile de créer des valeurs par défaut lors de la création d'un objet. Essentiellement, un constructeur est nécessaire pour initialiser automatiquement les variables.

Le constructeur initialise l'objet directement au moment de la création. Le nom du constructeur est le même que le nom de la classe, casse comprise, et la syntaxe du constructeur est similaire à une méthode sans valeur de retour.

Chat int privé (); // voici à quoi ressemble une méthode appelée Cat Cat() ; // voici à quoi ressemble le constructeur de la classe Cat

Contrairement à une méthode, un constructeur ne renvoie jamais rien.

Un constructeur définit les actions effectuées lorsqu'un objet d'une classe est créé et constitue une partie importante de la classe. En règle générale, les programmeurs essaient de spécifier explicitement le constructeur. S'il n'y a pas de constructeur explicite, Java en créera automatiquement un à utiliser par défaut. Quand nous avons implémenté la classe Boîte, alors aucun constructeur n'a été créé.

Ajoutons un constructeur à la classe qui définira simplement les valeurs initiales de la boîte.

Classe Box ( int width; // largeur de la boîte int hauteur; // hauteur de la boîte int profondeur; // profondeur de la boîte // Constructeur Box() ( width = 10; height = 10; profondeur = 10; ) // calculer le volume de la boîte int getVolume() (retour largeur * hauteur * profondeur; ) )

Nous avons temporairement supprimé la méthode setDim() et ajouté un constructeur. Voyons ce qui se passe:

Boîte catBox = new Box(); mInfoTextView.setText("Volume de la boîte : " + catBox.getVolume());

Le programme affichera le volume de la boîte, bien que nous n'ayons spécifié aucune dimension. Grâce au concepteur, toute boîte créée aura un volume fixe.

Naturellement, vous pouvez renvoyer la méthode setDim()(voir article sur les classes) et définissez vos dimensions pour la boîte :

Boîte catBox = new Box(); // définit nos propres dimensions pour la boîte catBox.setDim(10, 20, 30); mInfoTextView.setText("Volume de la boîte : " + catBox.getVolume());

Il devrait maintenant être clair pour vous que lorsqu'après le mot-clé nouveau nous écrivons le nom de la classe entre parenthèses, puis nous appelons le constructeur de la classe.

La question se pose - mais au début, lors de la création de la classe, nous n'avons pas créé un constructeur, mais le code nouvelle boîte() a travaillé. Le fait est que si le constructeur n'est pas défini explicitement, Java créera un constructeur qui sera utilisé par défaut. Dans ce cas, il attribuera simplement des valeurs nulles à toutes les variables. Si vous avez créé le constructeur vous-même, le constructeur par défaut ne sera pas utilisé.

Comme toute méthode, un constructeur peut avoir des arguments. Les arguments du constructeur transmettent des paramètres pour initialiser l'objet. Par exemple, si une classe Chat il y a un constructeur qui prend en argument un entier indiquant l'âge du chat, puis les objets Chat sera créé comme suit :

Chat chat = nouveau Chat(8); // le chat a 8 ans

Si Chat(int) est le seul constructeur de la classe, alors le compilateur ne permettra pas de créer des objets Chat d'une autre manière.

Cependant, revenons aux boîtes à chats. Le constructeur que nous avons créé n'est pas particulièrement utile, puisqu'il crée des boîtes identiques. Créons un constructeur avec des paramètres dans la classe Boîte et commentez le premier constructeur sans paramètre :

// Deuxième constructeur Box(int ​​​​w, int h, int d) ( width = w; height = h; profondeur = d; )

Si une classe contient un constructeur avec des paramètres, alors vous devrez spécifier les valeurs lors de la déclaration de la classe :

// Ce constructeur n'est plus valide // Box catBox = new Box(); // Dans le constructeur, vous devez spécifier les valeurs de taille de boîte Box catBox = new Box(100, 200, 100); mInfoTextView.setText("Volume de la boîte : " + catBox.getVolume());

D’ailleurs, avec un tel constructeur la méthode setDim() nous n'en avons plus besoin. On peut définir les dimensions de la boîte directement dans le constructeur. Comme la boîte est très probablement constante et ne change pas de taille, la méthode est peut-être superflue. Mais si on change la taille de la boite, il faudra quitter la méthode.

Une classe peut avoir plusieurs constructeurs. Décommentez le premier constructeur et créez deux boîtes : une boîte par défaut et une grande boîte.

Boîte defaultBox = new Box(); mInfoTextView.setText("Volume de la boîte standard : " + defaultBox.getVolume()); Boîte bigBox = nouvelle Boîte (100, 200, 200) ; mInfoTextView.append("\nVolume de la grande boîte : " + bigBox.getVolume());

Autrement dit, nous voyons que les constructeurs prennent en charge la surcharge, tout comme les méthodes.

Par exemple, nous pouvons créer un autre constructeur spécifiquement pour une boîte en forme de cube où tous les côtés sont égaux :

// Troisième constructeur pour le cube Box(int ​​​​len) ( width = height = profondeur = len; )

Calculez la taille du cube :

Boîte cube = nouvelle Boîte (5); int vol = cube.getVolume(); mInfoTextView.setText("Volume du cube : " + vol);

Utiliser un objet comme paramètres

Jusqu'à présent, nous avons utilisé des types simples comme paramètres dans les constructeurs. Mais vous pouvez également transmettre l'objet de la classe elle-même. Ajoutons un autre constructeur :

// Utiliser un objet de type Box Box(Box ob) ( width = ob.width; height = ob.height; profondeur = ob.profondeur; )

Dans le code du programme, vous pouvez utiliser le constructeur comme suit :

Boîte boîte1 = nouvelle boîte (100, 200, 100) ; Boîte cloneBox = new Box(box1); int vol = cloneBox.getVolume(); mInfoTextView.setText("Volume de la boîte : " + vol);

Classe de boîte (source)

paquet ru.alexanderklimov.box ; class Box ( int width; // largeur de la boîte int hauteur; // hauteur de la boîte int profondeur; // profondeur de la boîte // Constructeur Box() ( width = 10; height = 10; profondeur = 10; ) // Deuxième constructeur Box( int w, int h, int d) ( width = w; height = h; profondeur = d; ) // Troisième constructeur pour le cube Box(int ​​​​len) ( width = height = profondeur = len; ) // Utiliser un objet de type Box Box(Box ob) ( width = ob.width; height = ob.height; profondeur = ob.degree; ) // calcule le volume de la boîte int getVolume() ( return width * height * profondeur; ) // définit les dimensions de la boîte void setDim (int w, int h, int d) ( width = w; height = h; profondeur = d; ) )

Appel de constructeurs surchargés via this()

Lorsqu'il s'agit de constructeurs surchargés, il est pratique d'appeler un constructeur depuis un autre via un mot-clé ce. Lors de l'exécution du constructeur ce() Tout d'abord, le constructeur surchargé qui correspond à la liste de paramètres est exécuté. Les instructions à l'intérieur du constructeur d'origine sont ensuite exécutées, le cas échéant. Appeler le constructeur ce() doit être la première instruction du constructeur.

Tout d'abord, créons une classe qui n'utilise pas de constructeur ce() pour comprendre la différence.

Classe Cat ( int age; int birthday; // Initialise explicitement les variables Cat(int i, int j) ( age = i; birthday = j; ) // Initialise les variables avec la même valeur Cat(int i) ( age = i; anniversaire = i; ) // Définir les valeurs par défaut sur 0 Cat() ( age = 0; anniversaire = 0; ) )

Nous avons créé une classe avec trois constructeurs. Réécrivons la classe en utilisant le constructeur ce().

Class Cat( int age; int birthday; // Initialise explicitement les variables Cat(int i, int j) ( age = i; birthday = j; ) // Initialise les variables avec la même valeur Cat(int i) ( this( i, i); // appelé Cat(i, i); ) // Définir les valeurs par défaut sur 0 Cat() ( this(0); // appelé Cat(0); ) )

Nous n'avons maintenant qu'un seul constructeur qui attribue des valeurs aux champs - Cat(int, int). Que se passe-t-il lorsque l'instruction est exécutée :

Chat chat = nouveau Chat(8);

Appeler le constructeur Chat(8) provoque l'exécution du constructeur ceci(8, 8), ce qui équivaut à appeler le constructeur Chat(8, 8).

Que se passe-t-il lorsque l'instruction est exécutée :

Chat cat2 = nouveau Chat();

Dans ce cas, le constructeur s'appelle ceci(0), ce qui provoque l'exécution du constructeur Chat(0), puisque cette version particulière du constructeur correspond à la liste des paramètres. Dans ce cas, le constructeur Chat(0) appelle essentiellement le constructeur Chat(0, 0).

Utiliser des constructeurs surchargés via le constructeur ce() vous permet d'éliminer la duplication de code, réduisant ainsi le temps de chargement des classes.

Mais il faut être prudent car les constructeurs qui appellent le constructeur ce(), cours un peu plus lentement.

Constructeur privé

Parfois, une classe est créée uniquement pour stocker certains champs et méthodes statiques. Il est d'usage de donner des noms à ces classes Utilitaires, mais c'est facultatif. Une telle classe n'a pas besoin de constructeur, mais si l'auteur de la classe n'en a pas créé, le système lui-même créera un constructeur par défaut. Un tel constructeur n’a aucun sens et peut aussi être source d’erreurs. Pour vous prémunir contre ce problème, vous devez explicitement créer vous-même un constructeur vide et le rendre privé.

Classe publique Utils ( private Utils() ( throw new AssertionError(); ) ... //votre code correct // Code incorrect, pour démonstration uniquement ! public static void someMethod())( Utils utils = new Utils(); utils .toString(); ) )

Doubler lancer une nouvelle AssertionError() est facultatif, mais cela aidera à détecter l'erreur si vous appelez le constructeur dans la classe elle-même. Le compilateur ignorera cette option, mais le programme se terminera par une erreur.

Utils.someMethod(); // le programme se fermera avec une erreur

Vous ne pouvez pas créer de sous-classe pour cette classe.

Méthode en Java est un complexe d'expressions dont la combinaison vous permet d'effectuer une certaine opération. Ainsi, par exemple, lors de l'appel de la méthode System.out.println(), le système exécute une série de commandes pour imprimer un message sur la console.

À ce stade, vous apprendrez les techniques permettant de créer vos propres méthodes avec ou sans valeurs de retour, d'appeler des méthodes avec ou sans paramètres et d'isoler des méthodes lors du développement d'un programme.

Créer une méthode

Vous trouverez ci-dessous un exemple illustrant la syntaxe de la méthode permettant de créer une méthode en Java.

Syntaxe

public static int nom_méthode(int a, int b) ( // corps)

• public statique - modificateur ;
• int - type de retour ;
• methodName - nom de la méthode ;
• a, b - paramètres formels ;
• int a, int b - liste des paramètres.

Une définition de méthode est représentée par un en-tête de méthode et un corps de méthode. Nous pouvons voir la même chose dans la syntaxe de création de méthode suivante.

Syntaxe

modificateur returnType nameOfMethod (Liste de paramètres) ( // corps de la méthode)

La syntaxe ci-dessus inclut :

• modificateur – détermine le type d’accès à la méthode et la possibilité de son utilisation.
• returnType – la méthode peut renvoyer une valeur.
• nameOfMethod – spécifie le nom de la méthode. Une signature de méthode comprend le nom de la méthode et une liste de paramètres.
• Liste des paramètres – la liste des paramètres est représentée par le type, l'ordre et le nombre de paramètres de méthode. Cette option est définie arbitrairement ; la méthode peut contenir un paramètre nul.
• corps de méthode – le corps de méthode définit la méthode de travail avec les commandes.

Exemple

/* l'extrait de code renvoie le minimum entre deux nombres */ public static int minFunction(int n1, int n2) ( int min; if (n1 > n2) min = n2; else min = n1; return min; )

Appeler une méthode

Avant d'utiliser une méthode, il faut l'appeler. Il existe deux façons d'appeler une méthode en Java, à savoir La méthode renvoie une valeur ou non (il n'y a pas de valeur de retour).

L'algorithme pour appeler la méthode est assez simple. Lorsqu'un programme appelle une méthode en Java, le contrôle du programme est transféré à la méthode appelée. Cette méthode appelée rend alors le contrôle au client appelant dans deux cas si :

• l'instruction return est exécutée ;
• méthode se terminant par une accolade fermante atteinte.

La méthode de retour void appelle la commande. Regardons un exemple :

System.out.!");

La méthode de retour peut être illustrée par l'exemple suivant :

Int résultat = somme (6, 9);

L'exemple ci-dessous montre la manière de définir et d'appeler une méthode en Java.

Exemple

classe publique ExempleMinNumber ( public static void main(String args) ( int a = 11; int b = 6; int c = minFunction(a, b); System.out.println("Valeur minimale = " + c); ) / * Renvoie le minimum de deux nombres */ public static int minFunction(int n1, int n2) ( int min; if (n1 >

Valeur minimale = 6

Mot clé nul

Mot clé nul en Java nous permet de créer des méthodes qui ne renvoient pas de valeur. Dans l'exemple ci-dessous, nous avons examiné une méthode de type void – methodRankPoints. Les méthodes Void en Java ne renvoient aucune valeur. Une méthode de type void est appelée par une commande, c'est-à-dire méthodeRankPoints(255,7);. Il s'agit d'une expression Java qui se termine par un point-virgule, comme le montre l'exemple ci-dessous :

Exemple

public class ExempleVoid ( public static void main(String args) ( methodRankPoints(255.7); ) public static void methodRankPoints(double points) ( if (points >= 202.5) ( System.out.println("Rank A1"); )else if (points >= 122,4) ( System.out.println("Rank A2"); )else ( System.out.println("Rank A3"); ) ) )

En conséquence, le résultat suivant sera obtenu :

Rang A1

Passer des paramètres par valeur en Java

Lorsque le processus appelant s'exécute, Java transmet les arguments. La procédure doit être effectuée dans l'ordre spécifié par les paramètres pertinents dans la spécification de la méthode. Les paramètres peuvent être transmis par valeur ou par référence.

En Java, passer des paramètres par valeur signifie appeler une méthode avec un paramètre. De ce fait, la valeur de l'argument est transmise au paramètre.

Exemple

Le programme suivant montre un exemple de transmission d'un paramètre par valeur. Les valeurs des arguments restent inchangées même après l'appel de la méthode.

Public class swappingExample ( public static void main(String args) ( int a = 30; int b = 45; System.out.println("Avant de passer, les valeurs des arguments a = " + a + " et b = " + b ); // Appel de la méthode de transfert swapFunction(a, b); System.out.println("\nMaintenant, avant et après le passage des valeurs d'argument "); System.out.println("resté inchangé, a = " + a + " et b = " + b); ) public static void swapFunction(int a, int b) ( System.out.println("Avant remplacement : a = " + a + " b = " + b ); // Passage des paramètres int c = a; a = b; b = c; System.out.println("Après remplacement : a = " + a + " b = " + b); ) )

On obtient le résultat suivant :

Avant le transfert, les valeurs des arguments sont a = 30 et b = 45 Avant le remplacement : a = 30 b = 45 Après le remplacement : a = 45 b = 30 Maintenant, avant et après la transmission, les valeurs ​​des arguments sont restés inchangés, a = 30 et b = 45

Surcharge de méthode

Surcharge de méthode en Java- le cas où une classe contient deux ou plusieurs méthodes portant le même nom mais des paramètres différents. Ce processus est différent des méthodes prioritaires. Lors du remplacement de méthodes, la méthode est caractérisée par un nom, un type, un nombre de paramètres similaires, etc.

Considérez l'exemple présenté ci-dessus lors de la détermination des nombres minimaux d'un type entier. Supposons donc que nous souhaitions déterminer le nombre minimum d'un type double. Ce cas introduira le concept de surcharge pour créer deux ou plusieurs méthodes avec le même nom mais des paramètres différents.

L’exemple ci-dessus illustre ce qui précède.

Exemple

public class ExempleSurcharge ( public static void main(String args) ( int a = 7; int b = 3; double c = 5.1; double d = 7.2; int result1 = minFunction(a, b); // même fonction avec d'autres paramètres double result2 = minFunction(c, d); System.out.println("Valeur minimale = " + result1); System.out.println("Valeur minimale = " + result2); ) // pour un entier public static int minFunction ( int n1, int n2) ( int min; if (n1 > n2) min = n2; else min = n1; return min; ) // pour double public static double minFunction(double n1, double n2) ( double min; if ( n1 > n2) min = n2 ; sinon min = n1 ; retourner min ; ) )

En conséquence, le résultat suivant sera obtenu :

Valeur minimale = 3 Valeur minimale = 5,1

Les méthodes de surcharge rendent un programme lisible. Il existe donc deux méthodes portant le même nom mais des paramètres différents. En conséquence, nous avons reçu le numéro int minimum et le numéro de type double.

Utiliser des arguments de ligne de commande

Pendant le fonctionnement du programme, vous devrez peut-être transférer certaines informations. Cela peut être fait en Java en passant des arguments de ligne de commande à main().

En Java, un argument de ligne de commande représente les informations qui suivent directement le nom du programme sur la ligne de commande lors de son exécution. Accéder aux arguments de ligne de commande dans un programme Java n'est pas difficile. Ils sont stockés sous forme de chaîne dans le tableau de chaînes transmis à main().

Exemple

Le programme ci-dessous affiche tous les arguments de ligne de commande appelés.

Classe publique CommandLine ( public static void main(String args) ( for(int i = 0; i

Essayez d'exécuter ce programme comme indiqué ci-dessous :

$java CommandLine est la ligne de commande 300 -200

En conséquence, le résultat suivant sera obtenu :

Args : ce arguments : arguments de commande : arguments de chaîne : 300 arguments : -200

Constructeur en Java

En Java constructeur initialise un objet lors de sa création. Son nom est similaire au nom de la classe et sa syntaxe est similaire à celle d'une méthode. Cependant, contrairement à ce dernier, le constructeur n’a pas de valeur de retour.

Généralement, un constructeur en Java peut être utilisé pour attribuer une valeur initiale aux variables d'instance définies par une classe ou pour effectuer toute autre procédure de démarrage nécessaire pour créer un objet entièrement formé.

Les constructeurs sont présents dans toutes les classes, qu'ils soient spécifiés ou non, car Java fournit automatiquement un constructeur par défaut qui initialise toutes les variables membres de la classe à zéro. Cependant, une fois que vous aurez défini votre propre constructeur, le constructeur par défaut ne sera plus utilisé.

Exemple

L'exemple ci-dessous montre l'utilisation d'un constructeur de classe sans paramètres.

// Constructeur simple. class MyClass ( int x; // Vient ensuite le constructeur MyClass() ( x = 10; ) )

Pour initialiser des objets, vous devez effectuer un appel de constructeur selon l'exemple suivant.

Classe publique ConsDemo ( public static void main(String args) ( MyClass t1 = new MyClass(); MyClass t2 = new MyClass(); System.out.println(t1.x + " " + t2.x); ) )

On obtient le résultat :

Constructeur paramétré

Le plus souvent, vous aurez peut-être besoin d'un constructeur qui prend un ou plusieurs paramètres. Ajouter des paramètres à un constructeur revient à les ajouter à une méthode, sauf que vous les mettez entre parenthèses après le nom du constructeur.

Exemple

// Constructeur simple. class MyClass ( int x; // Ci-dessous se trouve le constructeur MyClass(int i) ( x = i; ) )

Afin d'initialiser des objets, vous devrez appeler le constructeur selon l'exemple suivant.

Classe publique ConsDemo ( public static void main(String args) ( MyClass t1 = new MyClass(10); MyClass t2 = new MyClass(20); System.out.println(t1.x + " " + t2.x); ) )

On obtient le résultat suivant :

Mot-clé ceci

Mot-clé ceci- utilisé pour faire référence à la classe actuelle étant donné un constructeur de méthode ou d'instance. En utilisant cela en Java, vous pouvez faire référence à des instances d'une classe, telles que des constructeurs, des variables et des méthodes.

Note: le mot-clé this est utilisé uniquement dans le cadre de méthodes ou de constructeurs d'instances.

Généralement, le mot-clé this en Java est utilisé pour :

• différenciation entre les variables d'instance et les variables locales lorsqu'elles portent le même nom, dans le cadre d'un constructeur ou d'une méthode.

classe Étudiant ( âge int; Étudiant (âge int) ( this.age = âge; ) )

• appeler un constructeur d'un type (constructeur paramétré ou constructeur par défaut) à partir d'un autre dans le cadre d'une classe. Ce processus est également appelé appel explicite de constructeur.

classe Étudiant ( int âge Étudiant() ( this(20); ) Étudiant(int âge) ( this.age = âge; ) )

Exemple

Classe publique This_Example ( // Initialise la variable num int num = 11; This_Example() ( System.out.println("Ceci est un exemple de programme avec le mot-clé this"); ) This_Example(int num) ( // Appelez la valeur par défaut constructor this( ); // Affectation de la variable locale num à la variable d'instance num this.num = num; ) public void greet() ( System.out.println("Bonjour ! Bienvenue dans ProgLang ! "); ) public void print () ( // Variable locale num int num = 20; // Appel de la méthode de classe greet this.greet(); // Imprimer la variable locale. System.out.println("La valeur de la variable locale num : " + num); // Imprimer la variable d'instance. System .out.println("Valeur de la variable d'instance num: " + this.num); ) public static void main(String args) ( // Initialiser la classe This_Example obj1 = new This_Example (); // Appel de la méthode print obj1.print() ; // Passage de la nouvelle valeur de la variable num via le constructeur paramétré This_Example obj2 = new This_Example(30); // Appel à nouveau de la méthode print obj2.print() ; ) )

En conséquence, le résultat suivant sera obtenu :

Ceci est un exemple de programme avec le mot-clé this Hello ! Bienvenue sur ProgLang ! Valeur de la variable locale num : 22 Valeur de la variable d'instance num : 11 Ceci est un exemple de programme avec le mot-clé this Hello ! Bienvenue sur ProgLang ! Valeur de la variable locale num : 22 Valeur de la variable d'instance num : 30

Arguments variables (var-args)

JDK 1.5 et versions ultérieures vous permettent de transmettre un nombre variable d'arguments du même type à une méthode. Le paramètre dans la méthode est déclaré comme suit :

TypeName...parameterName

Lors de la déclaration d’une méthode, vous spécifiez le type suivi de points de suspension (...). Un seul paramètre de longueur variable peut être spécifié dans une méthode, et ce paramètre doit être le dernier paramètre. Tous les paramètres réguliers doivent le précéder.

Exemple

public class VarargsDemo ( public static void main(String args) ( // Appel d'une méthode avec une variable args printMax(27, 11, 11, 5, 77.1); printMax(new double(10, 11, 12, 77, 71) ); ) public static void printMax(double... number) ( if (numbers.length == 0) ( System.out.println("Aucun argument n'est transmis"); return; ) double result = number; for (int i = 1; i résultat) résultat = nombres[i]; System.out.println("Valeur maximale " + résultat); ) )

En conséquence, le résultat suivant sera obtenu :

Valeur maximale 77,1 Valeur maximale 77,0

méthode finaliser()

méthode finaliser()- une méthode qui sera appelée juste avant que l'objet ne soit définitivement détruit par le garbage collector. (finaliseur). En Java, finalize() peut être utilisé pour garantir une finalisation propre d'un objet.

Par exemple, nous pouvons utiliser finalize() pour garantir qu'un fichier ouvert appartenant à un objet donné a été fermé.

Pour ajouter un finaliseur à une classe, il vous suffit de définir une méthode finalize() en Java. Le runtime Java appelle cette méthode immédiatement avant de traiter un objet de cette classe.

Dans le cadre de la méthode finalize(), vous spécifiez les actions qui doivent être effectuées avant la destruction de l'objet.

En général, la méthode finalize() ressemble à ceci :

Protected void finalize() ( // finalisation du code ici )

Ici, le mot-clé protected représente un spécificateur qui empêche l'accès à finalize() par du code défini en dehors de sa classe.

Cela indique que vous ne pouvez pas savoir comment ni même quand finalize() sera exécuté. Par exemple, si votre programme se termine avant le garbage collection, finalize() ne sera pas exécuté.

La fonction la plus importante de toute classe est le constructeur. Il vous permet d'instancier un objet. Si vous n'avez pas de constructeur, un constructeur par défaut est créé :

Utilisateur de classe publique (
âge int;//champ
Chaîne prénom;//champ
Chaîne nom de famille ; // champ
User() (//voici à quoi ressemble le constructeur par défaut
//vide
}
}

Comme vous l'avez peut-être remarqué, le constructeur porte le même nom que le nom de la classe.
Les constructeurs, comme les fonctions, peuvent prendre en entrée un certain ensemble de paramètres, qu'ils utilisent ensuite lors de la création d'un objet.

Utilisateur de classe publique (
âge int;//champ
Chaîne prénom;//champ
Chaîne nom de famille ; // champ
public User (int age, String firstName, String lastName) (//constructeur avec trois paramètres
this.age = âge;
this.firstName = firstName;
this.lastName = lastName;
}
}

Évidemment, les constructeurs sont appelés lors de la création d'un objet :

Utilisateur user = new User(18,"Bendjamin","Button");

Ainsi, nous avons créé un objet de la classe User dont le champ Age contient les valeurs 18, firstName Benjamin et lastName Button.
Utiliser ce constructeur est beaucoup plus pratique que si nous essayions de le faire manuellement :

Utilisateur utilisateur = nouvel utilisateur ();
utilisateur.age = 18 ;
user.firstName = "Bendjamin";
user.lastName = "Bouton" ;

De plus, si vous utilisez des constructeurs, le constructeur par défaut n'est pas créé. Ainsi, si nous n’avons qu’un constructeur avec trois paramètres, alors nous ne pouvons pas créer un objet de cette classe sans l’appeler :

Utilisateur user = new User();//erreur, constructeur par défaut manquant

Passons à quelques cadeaux d'IntelliJ Idea. Appuyez sur alt+insertion :

Il s'agit d'un menu permettant de générer automatiquement des éléments utiles pour la classe. Ce qui nous intéresse ici aujourd’hui, c’est l’élément Constructeur. Désormais, si vous avez des champs dans votre classe, vous pouvez choisir parmi quels champs vous souhaitez créer un constructeur, et l'environnement de programmation écrira son code pour vous. Si vous avez besoin d'un autre constructeur, appuyez à nouveau sur les précieux boutons et ajoutez-en un autre :

Utilisateur de classe publique (
âge int;//champ
Chaîne prénom;//champ
Chaîne nom de famille ; // champ
Utilisateur public (int age, String firstName, String lastName) (
this.age = âge;
this.firstName = firstName;
this.lastName = lastName;
}

Utilisateur public (âge int) (
this.age = âge;
}
}

Regardons maintenant la ligne étrange this.Variablename = Variablename. Le mot-clé this indique que l'instance actuelle de la classe doit se voir attribuer la valeur transmise au constructeur. Ainsi, si nous devions écrire en dehors de la classe, alors user.age = age, où age est une variable régulière.
A l'intérieur des constructeurs, vous pouvez appeler d'autres constructeurs, par exemple :

Utilisateur de classe publique (
âge int;//champ
Chaîne prénom;//champ
Chaîne nom de famille ; // champ

Utilisateur public (int age, String firstName, String lastName) (
this.age = âge;
this.firstName = firstName;
this.lastName = lastName;
}

Utilisateur public (âge int) (
this(age,"unknown", "unknown");//appelle le constructeur avec trois paramètres
}
}

De plus, si votre classe a utilisé l'héritage, alors pour appeler le constructeur parent, vous devez utiliser le super mot-clé
Les constructeurs sont nécessaires pour la configuration initiale d'un objet, si vous devez effectuer certaines actions avec des champs, par exemple les initialiser.

1. Le concept de constructeur par défaut

Un constructeur par défaut est un constructeur qui n'a aucun paramètre. Le constructeur par défaut peut être déclaré explicitement dans la classe ou généré automatiquement.

Dans le cas le plus général, pour la classe ClassName, le constructeur par défaut est le suivant :

classe Nom du cours(... // déclaration du constructeur Nom du cours() ( // corps du constructeur // ... } ... }

2. Dans quels cas le constructeur par défaut est-il généré automatiquement dans une classe et dans quels cas ne l'est-il pas ? Exemple

Si aucun constructeur n'est déclaré dans la classe, alors un constructeur par défaut sera généré. Autrement dit, un constructeur par défaut est généré automatiquement dans une classe uniquement si la classe ne contient pas d'implémentations d'autres constructeurs. Si une classe contient une implémentation d'au moins un constructeur avec des paramètres, alors pour déclarer un constructeur par défaut, il doit être déclaré explicitement dans la classe.

Par exemple. Dans la déclaration de classe suivante, le constructeur par défaut est généré automatiquement

classe CMMaClasse( int d ; int Obtenir d() ( retour d ; ) vide EnsembleD( int nd) ( d = nd; ) )

Le code ci-dessus signifie que vous pouvez déclarer un objet de classe en utilisant le constructeur par défaut :

// fonctionne car la classe n'implémente plus aucun constructeur CMiClasse mc = nouveau CMaClasse();

Si vous ajoutez au moins un autre constructeur au corps de la classe CMyClass (par exemple, un constructeur avec un paramètre), alors le constructeur par défaut ne sera pas généré automatiquement

classe CMMaClasse( int d ; // le constructeur par défaut n'est plus généré automatiquement CMMaClasse( int nd) ( d = nd; ) int Obtenir d() ( retour d ; ) vide Ensemble( int nd) ( d = nd; ) )

Après l'implémentation ci-dessus, il ne sera plus possible de déclarer un objet en utilisant le constructeur par défaut. Cependant, il est possible de déclarer un objet à l'aide d'un constructeur à un paramètre

// erreur de compilation, puisqu'un autre constructeur est déjà déclaré dans la classe // CMyClass mc = new CMyClass(); CMiClasse mc2 = nouveau CMaClasse(7); // et ce code fonctionne

L'exécution de la ligne ci-dessus entraînera une erreur de compilation :

Le constructeur CMyClass() n'est pas défini

Afin d'avoir une implémentation de constructeur par défaut et de déclarer un objet de classe à l'aide d'un constructeur par défaut, celui-ci doit être spécifié explicitement. Cela pourrait être par exemple comme ça

classe CMMaClasse( int d ; // déclaration explicite du constructeur par défaut CMiClass() ( d = 0; ) // déclaration d'un constructeur avec 1 paramètre, CMMaClasse( int nd) ( d = nd; ) int Obtenir d() ( retour d ; ) vide Ensemble( int nd) ( d = nd; ) )

Après cette implémentation, vous pouvez créer une instance de la classe en utilisant deux constructeurs, par exemple

CMiClasse mc = nouveau CMaClasse(); // le constructeur par défaut est appelé mc.d = 25 ; CMiClasse mc2 = nouveau CMaClasse(5); // le constructeur avec 1 paramètre est appelé

3. Appel de constructeurs à partir d'autres constructeurs. Exemple

Le langage de programmation Java permet d'appeler les constructeurs d'une classe depuis un autre constructeur de la même classe. Pour ce faire, utilisez le mot-clé this, qui est un lien vers la classe actuelle.

Exemple. L'exemple montre l'utilisation de la classe CPixel, qui implémente un pixel sur un écran de moniteur.

// Classe qui implémente un pixel sur l'écran du moniteur publique classe CPixel ( // variables de classe internes privé int x, y ; // coordonnées des pixels privé int couleur ; // couleur des pixels // constructeur sans paramètres (constructeur par défaut) CPixel() ( x = y = couleur = 0; ) // constructeur avec 2 paramètres qui initialisent uniquement les coordonnées CPixel( int _X, int _y) ( x = _x; y = _y; couleur = 0; ) // constructeur avec 1 paramètre qui initialise uniquement la couleur CPixel( int _color) ( couleur = _color; x = y = 0; ) // un constructeur à 3 paramètres qui appelle un constructeur à 2 paramètres CPixel ( int _X, int _oui, int _couleur) ( // appel d'un constructeur avec 2 paramètres : la première opération est obligatoire et une seule fois ce(_x, _y); //cette couleur); // il est interdit d'appeler à nouveau le constructeur ce.color = _color; // donc c'est possible ) // méthodes d'accès int GetX() ( retour X ; ) int ObtenirY() ( retour oui ; ) int ObtenirCouleur() ( retour couleur ; ) )

Utilisation de la classe CPixel dans un autre code de programme (méthode)

CPixel cp1 = nouveau CPixel(2,8); // appel d'un constructeur avec 2 paramètres CPixel cp2 = nouveau CPixel(3,5,8); // appelle un constructeur qui appellera un autre constructeur int d; d = cp1.GetX(); // d = 2 d = cp2.GetColor(); // d = 8 d = cp2.GetY(); // ré = 5 ...

4. Quelles restrictions (exigences) sont imposées lors de l'appel d'autres constructeurs à partir du constructeur de classe ?

Pour appeler correctement d'autres constructeurs à partir d'un constructeur de classe, vous devez respecter les exigences (restrictions) suivantes :

• Vous ne pouvez appeler qu’un seul autre constructeur de classe. Il est interdit d'appeler deux ou plusieurs autres constructeurs de cette classe. Cela s'ensuit logiquement qu'un constructeur de classe est destiné à créer un objet de classe une seule fois (et non deux ou plusieurs fois) ;
• un appel à un autre constructeur doit être la première opération dans le constructeur appelant. Si dans le constructeur appelant un appel à un autre constructeur est implémenté comme deuxième (troisième, etc.) opération, le compilateur générera une erreur.