Bien sûr !
Voici un **cours détaillé et clair** sur les **constructeurs en Java**, la création d’instances,
les types de référence, la surcharge des constructeurs, et la valeur spéciale `null`.
---
# 📚 Cours détaillé : Constructeurs, Instances et Références en Java
---
## 1️⃣ Constructeur en Java
### Qu’est-ce qu’un constructeur ?
* Le **constructeur** est une méthode spéciale d’une classe.
* Son rôle principal est d’**initialiser un objet** lors de sa création.
* Le constructeur porte le **même nom que la classe**.
* Il ne retourne **rien** (pas même `void`).
---
### Exemple simple
```java
public class Maths {
public Maths() {
System.out.println("I am constructor");
}
public static void main(String[] args) {
System.out.println("I am main");
Maths obj1 = new Maths(); // appel du constructeur
```
**Explication :**
* Quand on fait `new Maths()`, le constructeur `Maths()` est appelé.
* Cela affiche :
```
I am main
I am constructor
```
---
## 2️⃣ Création d’une instance (objet)
* Pour créer un objet, on utilise le mot-clé `new` suivi du constructeur.
* Le constructeur peut recevoir des paramètres pour initialiser les variables d’instance.
### Exemple avec paramètres
```java
public class Person {
int age;
public Person(int a) { // constructeur avec paramètre
age = a;
public static void main(String[] args) {
Person p = new Person(20); // création d'une instance avec âge 20
System.out.println("Age is " + p.age); // Affiche: Age is 20
```
---
## 3️⃣ Types de données référence (Reference Data Types)
* En Java, une variable d’un type **référence** ne contient pas directement la valeur, mais une
**adresse mémoire** pointant vers l’objet.
* Le type référence correspond au nom de la classe.
### Exemple avec la classe `Cat`
```java
public class Cat {
public Cat() {
// instructions pour créer un chat
public static void main(String[] args) {
Cat garfield = new Cat(); // garfield est une référence à un objet Cat
System.out.println(garfield); // Exemple de sortie : Cat@76ed5528
```
* L’impression `Cat@76ed5528` correspond à la **référence mémoire** de l’objet (adresse, identifiant).
---
## 4️⃣ Surcharge des constructeurs (Constructor Signatures)
* Une classe peut avoir **plusieurs constructeurs**, différenciés par leur **liste de paramètres**
(signature).
* Cela s’appelle la **surcharge**.
* Le compilateur choisit le constructeur à appeler selon les arguments fournis.
### Exemple
```java
public class Cat {
String furType;
boolean containsClaws;
// Constructeur avec paramètres
public Cat(String furLength, boolean hasClaws) {
furType = furLength;
containsClaws = hasClaws;
public static void main(String[] args) {
Cat garfield = new Cat("Long-hair", true);
```
---
## 5️⃣ La valeur spéciale `null`
* `null` signifie qu’une variable **référence aucun objet**.
* Une variable peut être initialisée à `null` pour indiquer qu’elle ne pointe vers rien.
### Exemple
```java
public class Bear {
String species;
public Bear(String speciesOfBear) {
species = speciesOfBear;
public static void main(String[] args) {
Bear baloo = new Bear("Sloth bear");
System.out.println(baloo); // Affiche quelque chose comme Bear@4517d9a3
baloo = null; // baloo ne référence plus d’objet
System.out.println(baloo); // Affiche: null
```
---
## 🔑 Résumé
| Concept | Description | Exemple |
| ---------------------- | --------------------------------------------------- | -------------------------------------------- |
| Constructeur | Méthode spéciale pour initialiser un objet | `public Person(int age) { this.age
= age; }` |
| Création d’instance | `new ClassName(...)` crée un nouvel objet | `Person p = new Person(20);`
|
| Type référence | Variable qui référence un objet en mémoire | `Cat garfield = new Cat();`
|
| Surcharge constructeur | Plusieurs constructeurs avec différentes signatures | `Cat(String fur, boolean
claws)` et `Cat()` |
| Valeur `null` | Référence qui ne pointe vers aucun objet | `baloo = null;` |
Super ! Voici une **série d’exercices sur les constructeurs, instances, types de référence et null** — du
facile au difficile — pour bien pratiquer ces concepts.
---
# 🧪 Exercices : Constructeurs et Instances en Java
---
## Niveau Facile
### Exercice 1
Crée une classe `Car` avec un attribut `String model`.
Ajoute un constructeur qui initialise `model`.
Dans `main`, crée une instance de `Car` avec le modèle `"Tesla"` et affiche le modèle.
---
### Exercice 2
Crée une classe `Book` avec deux attributs : `String title` et `String author`.
Ajoute un constructeur pour initialiser les deux attributs.
Crée un objet `Book` et affiche ses informations.
---
## Niveau Moyen
### Exercice 3
Modifie la classe `Book` pour avoir deux constructeurs :
* Un constructeur avec paramètres `title` et `author`.
* Un constructeur sans paramètres qui initialise `title` et `author` avec `"Unknown"`.
Teste les deux constructeurs dans `main`.
---
### Exercice 4
Crée une classe `Student` avec attributs `name` (String) et `age` (int).
Ajoute un constructeur avec paramètres.
Ajoute une méthode `isAdult()` qui retourne `true` si l’âge est au moins 18, sinon `false`.
Dans `main`, crée plusieurs étudiants et affiche qui est majeur.
---
## Niveau Difficile
### Exercice 5
Crée une classe `Rectangle` avec `width` et `height`.
Ajoute deux constructeurs :
* Un constructeur avec paramètres.
* Un constructeur sans paramètres qui initialise `width` et `height` à 1.
Ajoute une méthode `area()` qui retourne l’aire du rectangle.
Teste les deux constructeurs et affiche les aires.
---
### Exercice 6
Crée une classe `Dog` avec `name` et `breed`.
Dans `main`, crée une variable `Dog dog1` initialisée à `null`.
Teste si `dog1` est `null` avant de créer un nouvel objet `Dog`.
Affiche un message adapté selon que `dog1` est `null` ou non.
