Vous êtes sur la page 1sur 7

developpement-informatique.

com

les constructeurs en Java


Developpement-informatique.com

6-7 minutes

les constructeurs en Java

Les constructeurs sont utilisés pour initialiser l’état de l’objet. Comme les méthodes, un constructeur

contient également une collection d'instructions qui sont exécutées au moment de la création de l'objet.

Chaque fois qu'un objet est créé à l'aide du mot-clé new, au moins un constructeur (il peut s'agir d'un

constructeur par défaut) est appelé pour affecter des valeurs initiales aux données membres de la

même classe.

Un constructeur est appelé lors de la création d'un objet ou d'une instance.

Exemple 1 :

1 public class Personne {

2     private String nom;

3     private int age;

4     public Personne(String nom, int age) {

5         System.out.println("Je suis le constructeur");

6         this.nom = nom;

7         this.age = age;

8     }

9     public static void main(String args[]) {

10         Personne p = new Personne("ESSADDOUKI", 32);

11     }

12 }
13

14

15

16

Règles pour définir un Constructeur

Les constructeurs d'une classe doivent avoir le même nom que le nom de la classe dans laquelle

elle réside.

Un constructeur en Java ne peut pas être abstrait, final, statique et synchronisé.

Les modificateurs d’accès peuvent être utilisés dans la déclaration du constructeur pour contrôler

son accès, c’est-à-dire quelle classe peut appeler le constructeur.

Types de constructeur

Il existe deux types de constructeur en Java

Constructeur sans argument : Un constructeur sans paramètre est appelé constructeur par

défaut. Si nous ne définissons pas de constructeur dans une classe, le compilateur crée un

constructeur par défaut (sans argument) pour la classe. Et si nous écrivons un constructeur avec

des arguments ou sans arguments, le compilateur ne crée pas de constructeur par défaut.

Le constructeur par défaut fournit les valeurs par défaut à l'objet, telles que 0, null, etc., en

fonction du type.

Exemple 2 :

1 public class Personne {

2     private String nom;

3     private int age;

4     public Personne() {

5         System.out.println("Je suis le constructeur");

6     }

7     public void affiche() {


8         System.out.println("nom : " + nom);

9         System.out.println("age : " + age);

10     }

11     public static void main(String args[]) {

12         Personne p = new Personne();

13         p.affiche();

14     }

15 }

16

17

18

19

20

21

Je suis le constructeur

nom : null

age : 0

Constructeur paramétré: Un constructeur qui a des paramètres est appelé constructeur

paramétré. Si nous voulons initialiser les champs de la classe avec vos propres valeurs, utilisez

un constructeur paramétré.

Exemple 3 :

1 public class Personne {

2     private String nom;

3     private int age;

4     public Personne(String nom, int age) {


5         System.out.println("Je suis le constructeur");

6         this.nom = nom;

7         this.age = age;

8     }

9     public void affiche() {

10         System.out.println("nom : " + nom);

11         System.out.println("age : " + age);

12     }

13     public static void main(String args[]) {

14         Personne p = new Personne("ESSADDOUKI", 32);

15         p.affiche();

16     }

17 }

18

19

20

21

22

23

Je suis le constructeur

nom : ESSADDOUKI

age : 32

Remarque !  Il n'y a pas d'instructions de "return" dans le constructeur, mais le constructeur retourne

l'instance de classe actuelle. Nous pouvons écrire "return" dans un constructeur.

Surcharge constructeur
Comme les méthodes, nous pouvons surcharger les constructeurs pour la création d'objets de

différentes manières. Le compilateur différencie les constructeurs en fonction du nombre de paramètres,

des types de paramètres et de l'ordre des paramètres.

Exemple 4 :

1 public class Personne {

2     private String nom;

3     private int age;

4     public Personne() {

5         System.out.println("je suis le constructeur par défaut");

6     }

7     public Personne(String nom, int age) {

8         System.out.println("Je suis le constructeur paramétré (nom -


age)");
9

        this.nom = nom;
10

        this.age = age;
11

    }
12

    public Personne(int age, String nom) {


13

        System.out.println("Je suis le constructeur paramétré (age -


14
nom)");
15
        this.nom = nom;
16
        this.age = age;
17
    }
18
    public static void main(String args[]) {
19
        Personne p1 = new Personne("ESSADDOUKI", 32);
20
        Personne p2 = new Personne();
21
22         Personne p3 = new Personne(32, "ESSADDOUKI");

23     }

24 }

25

26

27

28

29

Je suis le constructeur paramétré (nom - age)

je suis le constructeur par défaut

Je suis le constructeur paramétré (age - nom)

En quoi les constructeurs sont-ils différents des méthodes en Java?

Les constructeurs doivent avoir le même nom que la classe dans laquelle ils ont été définis, ce

qui n'est pas nécessaire pour la méthode en java.

Les constructeurs ne renvoient aucun type tandis que les méthodes ont le type de retour ou void

si ne renvoie aucune valeur.

Le constructeur n’est appelé qu’une fois au moment de la création de l’objet, tandis que les

méthodes peuvent être appelées n’importe quel nombre de fois.

Partager ce cours avec tes amis :


The education of the 21st century opens up opportunities to not merely teach, but to coach, mentor,

nurture and inspire.

Vous aimerez peut-être aussi