Java

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 :
                                    public class Personne {
                                        private String nom;
                                        private int age;
                                    
                                        public Personne(String nom, int age) {
                                            System.out.println("Je suis le constructeur");
                                            this.nom = nom;
                                            this.age = age;
                                    
                                        }
                                    
                                        // méthode principale (main)
                                        public static void main(String args[]) {
                                            Personne p = new Personne("ESSADDOUKI", 32);
                                        }
                                    }
                            
Je suis le constructeur
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 :
                                                public class Personne {
                                                    private String nom;
                                                    private int age;
                                                    
                                                    // constructeur par défaut
                                                    public Personne() {
                                                        System.out.println("Je suis le constructeur");
                                                
                                                    }
                                                
                                                    public void affiche() {
                                                        System.out.println("nom : " + nom);
                                                        System.out.println("age : " + age);
                                                    }
                                                
                                                    // méthode principale (main)
                                                    public static void main(String args[]) {
                                                        Personne p = new Personne();
                                                        p.affiche();
                                                    }
                                                }
                                        
    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 :
                                                public class Personne {
                                                    private String nom;
                                                    private int age;
                                                
                                                    // constructeur paramétré
                                                    public Personne(String nom, int age) {
                                                        System.out.println("Je suis le constructeur");
                                                        this.nom = nom;
                                                        this.age = age;
                                                
                                                    }
                                                
                                                    public void affiche() {
                                                        System.out.println("nom : " + nom);
                                                        System.out.println("age : " + age);
                                                    }
                                                
                                                    // méthode principale (main)
                                                    public static void main(String args[]) {
                                                        Personne p = new Personne("ESSADDOUKI", 32);
                                                        p.affiche();
                                                    }
                                                }
                                        
    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 :
                                    public class Personne {
                                        private String nom;
                                        private int age;
                                    
                                        public Personne() {
                                            System.out.println("je suis le constructeur par défaut");
                                        }
                                    
                                        // constructeur paramétré
                                        public Personne(String nom, int age) {
                                            System.out.println("Je suis le constructeur paramétré (nom - age)");
                                            this.nom = nom;
                                            this.age = age;
                                        }
                                    
                                        // constructeur paramétré
                                        public Personne(int age, String nom) {
                                            System.out.println("Je suis le constructeur paramétré (age - nom)");
                                            this.nom = nom;
                                            this.age = age;
                                        }
                                    
                                        // méthode principale (main)
                                        public static void main(String args[]) {
                                            Personne p1 = new Personne("ESSADDOUKI", 32);
                                            Personne p2 = new Personne();
                                            Personne p3 = new Personne(32, "ESSADDOUKI");
                                        }
                                    }
                            
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 :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :