Les constructeurs de classe en Java
Sommaire
- 1- Objectifs
- 2- Présentation
- 3- Syntaxe et utilisation
- 4- Créer un constructeur en Java
- 5- Types de constructeurs en Java
- 5.1- Constructeur par défaut
- 5.2- Constructeur nommé (en Java : constructeur avec surcharge) :
- 5.3- Constructeur paramètré
- 5.3.1- Syntaxe
- 6- Applications
- 6.1- App01
- 6.2- App02
- 6.2.1- Cours JAVA
Les constructeurs de classe en Java
-
Objectifs
- Comprendre le concept fondamental d’objets en programmation orientée objet (POO) et comment il se distingue d’autres paradigmes de programmation.
- Apprendre à créer des classes en Java, incluant la définition de propriétés et de méthodes, ainsi que la gestion de la visibilité des membres (public, privé, protégé).
-
Présentation
- Le constructeur est une méthode spéciale utilisée pour initialiser un objet lorsqu’il est créé dans le programme. En programmation orientée objet, lorsqu’un objet est créé, il appelle automatiquement le constructeur. Toutes les classes ont leur constructeur par défaut, créé par le compilateur lorsque la classe est appelée, mais vous pouvez également définir votre propre constructeur.
- L’instanciation d’un objet se fait par l’appel à un constructeur. La syntaxe pour cela en Java est la suivante : le constructeur porte le même nom que la classe, il n’a pas de type de retour et il est automatiquement appelé lors de la création d’un objet. Si aucun constructeur n’est spécifié, le constructeur par défaut sans argument est utilisé. Par exemple, si une classe a un attribut nom, le paramètre devra être affecté avec this.nom.
-
Syntaxe et utilisation
- Les constructeurs ont le même nom que la classe et n’ont pas de type de retour. Voici la syntaxe générale :
- Dans la syntaxe ci-dessus :
NomDeClasse
est le nom de la classe dont le constructeur est créé.Les paramètres
sont optionnels et peuvent être définis ou non pour le constructeur. Le constructeur par défaut ne contient aucun paramètre.Le corps du constructeur
est le corps du constructeur et est exécuté lorsque le constructeur est appelé, c’est-à-dire lorsqu’un objet est créé.-
Créer un constructeur en Java
- Voyons comment écrire un constructeur de base en Java. Comme mentionné, un constructeur porte le même nom que la classe et ne renvoie aucune valeur. Supposons que nous ayons une classe Etudiant, le constructeur doit également s’appeler Etudiant. Voici un exemple :
-
Types de constructeurs en Java
- En Java, il existe plusieurs types de constructeurs que vous pouvez utiliser pour initialiser une classe. Voici les principaux types :
-
Constructeur par défaut
- Java crée automatiquement un constructeur par défaut si vous n’en définissez pas explicitement un. Ce constructeur initialise les propriétés à leurs valeurs par défaut (0 pour les types numériques, null pour les types objets, etc.).
-
Constructeur nommé (en Java : constructeur avec surcharge) :
- En Java, vous pouvez définir plusieurs constructeurs pour une même classe grâce à la surcharge. Chaque constructeur peut accepter différents ensembles de paramètres.
-
Constructeur paramètré
- Les constructeurs paramétrés en Java sont des constructeurs qui acceptent des paramètres pour initialiser les propriétés de la classe.
-
Syntaxe
- Dans cet exemple, la classe Chat présente plusieurs constructeurs, dont un sans paramètre, un avec des paramètres, et un autre avec un seul paramètre.
-
Applications
-
App01
- Votre classe Car et son constructeur ici
- Votre tâche est de compléter ce code en créant la classe Car, en ajoutant le constructeur et la méthode printDetails(), puis en créant une instance de la classe Car dans la fonction main() et en appelant la méthode printDetails() sur cette instance.
-
App02
- Soit la classe Chien suivant
- Ajoutez une propriété age à la classe Chien. Modifiez les constructeurs pour inclure cette nouvelle propriété.
- Ajoutez un constructeur paramétré à la classe Chien qui prend le nom et l’âge comme paramètres.
- Ajoutez un constructeur nommé Chien.adulte qui crée un chien avec un âge par défaut de 3 ans.
class NomDeClasse {
NomDeClasse([paramètres]) {
// Corps du constructeur
}
}
public class Etudiant {
public Etudiant(String nom, int age) {
System.out.println("Le nom est : " + nom);
System.out.println("L'âge est : " + age);
}
public static void main(String[] args) {
// Création d'un objet
Etudiant etudiant = new Etudiant("Ahmed", 26);
}
}
class Person {
String name;
int age;
}
public class Main {
public static void main(String[] args) {
// Création d'une instance de Person en utilisant le constructeur par défaut
Person person = new Person();
person.name = "Alice";
person.age = 30;
System.out.println("Name: " + person.name + ", Age: " + person.age);
}
}
class Personne {
String nom;
String prenom;
String telephone;
String adresse;
// Constructeur avec tous les attributs
Personne(String prenom, String nom, String telephone, String adresse) {
this.prenom = prenom;
this.nom = nom;
this.telephone = telephone;
this.adresse = adresse;
}
// Constructeur pour prénom et nom seulement
Personne(String prenom, String nom) {
this.prenom = prenom;
this.nom = nom;
}
}
class Chat {
String nom;
String couleur;
int age;
// Constructeur paramétré
Chat(String nom, String couleur, int age) {
this.nom = nom;
this.couleur = couleur;
this.age = age;
}
// Constructeur nommé avec un paramètre
Chat(String nom) {
this.nom = nom;
}
// Constructeur vide
Chat() {
// initialisation par défaut si nécessaire
}
}
-
1. Créez une classe appelée `Car` avec les propriétés `make`, `model` et `year`.
2. Ajoutez un constructeur à la classe `Car` qui prend ces trois propriétés comme paramètres et initialise les champs correspondants.
3. Ajoutez une méthode `printDetails()` à la classe `Car` qui imprime les détails de la voiture de la manière suivante : « Make: …, Model: …, Year: … ».
4. Dans la fonction main, créez une instance de la classe `Car` en utilisant le constructeur, puis appelez la méthode `printDetails()` sur cette instance.
void main() {
// Votre code ici
}
Solution
class Chien {
var nom;
// constructeur simple
Chien() {
this.nom = 'inconu';
}
// constructeur nommé
Chien.nom(this.nom);
}
main() {
var chien = Chien.nom('Tango');
print(chien.nom);
}
Solution
class Chien {
var nom;
var age;
Chien() {
this.nom = 'inconnu';
}
Chien.nom(this.nom);
// Nouveau constructeur nommé avec l'âge
Chien.nomEtAge(this.nom, this.age);
}
main() {
var chien1 = Chien.nom('Tango');
print(chien1.nom);
var chien2 = Chien.nomEtAge('Bella', 3);
print(chien2.nom);
print(chien2.age);
}
Solution
class Chien {
var nom;
var age;
Chien() {
this.nom = 'inconnu';
}
Chien.nom(this.nom);
Chien.nomEtAge(this.nom, this.age);
// Nouveau constructeur paramétré
Chien.parametre(this.nom, this.age);
}
main() {
var chien1 = Chien.nom('Tango');
print(chien1.nom);
var chien2 = Chien.nomEtAge('Bella', 3);
print(chien2.nom);
print(chien2.age);
var chien3 = Chien.parametre('Charlie', 2);
print(chien3.nom);
print(chien3.age);
}
Solution
class Chien {
var nom;
var age;
Chien() {
this.nom = 'inconnu';
}
Chien.nom(this.nom);
Chien.nomEtAge(this.nom, this.age);
Chien.parametre(this.nom, this.age);
// Nouveau constructeur nommé avec une logique spécifique
Chien.adulte(this.nom) {
this.age = 3;
}
}
main() {
var chien1 = Chien.nom('Tango');
print(chien1.nom);
var chien2 = Chien.nomEtAge('Bella', 3);
print(chien2.nom);
print(chien2.age);
var chien3 = Chien.parametre('Charlie', 2);
print(chien3.nom);
print(chien3.age);
var chien4 = Chien.adulte('Max');
print(chien4.nom);
print(chien4.age);
}