# 🟧 1. Structure d’un programme Java
Java est un langage orienté objet où _tout_ est organisé autour des classes.
Avant même de manipuler des objets, il faut comprendre comment est structuré un programme.
Une classe regroupe :
- des **attributs** (Ă©tat)
- des **méthodes** (comportements)
- Ă©ventuellement des **constructeurs** (initialisation)
Un fichier Java ne peut contenir **qu’une seule classe publique**, et son nom **doit obligatoirement correspondre au fichier**.
Cela vient du fait que le compilateur et la JVM s’appuient sur cette correspondance pour retrouver le point d’entrée du programme.
`MaClasse.java`
Structure minimale d’un fichier :
```java
public class MaClasse {
}
```
Cette classe est pour l’instant vide : elle définit un nouveau type de données, mais sans contenu.
Le point d’entrée d’un programme Java reste toujours :
```java
public static void main(String[] args) {
}
```
Cette méthode est appelée automatiquement lorsque le programme démarre.
Elle n’a pas besoin d’être présente dans toutes les classes — uniquement dans celle qui doit lancer l’application.
# 🟦 2. Création d’une classe
Créer une classe revient à définir un **nouveau type d’objet** que le programme pourra manipuler.
Dans un premier temps, cette classe est simplement un conteneur, un “moule” vide.
```java
public class Voiture {
}
```
La classe _décrit le concept_ : ici une voiture.
Elle ne possède encore :
- ni **attributs** → donc aucun état,
- ni **méthodes** → donc aucun comportement.
-
Elle n’est pas encore utilisable, mais elle constitue la base de la conception orientée objet.
# đźź© 3. Attributs
Les attributs sont les **données** qui caractérisent un objet.
Ils représentent l’**état** d’une instance de la classe.
```java
public class Voiture {
private int vitesse;
private String marque;
}
```
### âś” Pourquoi `private` ?
L’encapsulation est fondamentale en Java :
- elle empêche d’accéder directement aux données internes,
- elle protège l’intégrité de l’objet,
- elle garantit que les modifications passeront par des méthodes prévues.
➡️ On ne manipule _jamais_ directement les attributs depuis l’extérieur.
### ✔ Un attribut ≠une variable locale
- **Attribut** = lié à l’objet (durée de vie = durée de l’objet)
- **Variable locale** = liée à la méthode (durée de vie = exécution de la méthode)
# 🟪 4. Méthodes
Les méthodes décrivent **ce que sait faire un objet**.
Elles permettent de :
- modifier ses attributs,
- accéder à ses valeurs,
- effectuer une action.
```java
public class Voiture {
private int vitesse;
public void demarrer() {
vitesse = 10;
}
public void accelerer() {
vitesse += 10;
}
public int getVitesse() {
return vitesse;
}
}
```
### ✔ Méthodes avec paramètres
Elles permettent de passer des informations aux objets :
```java
public void augmenterDe(int delta) {
vitesse += delta;
}
```
### ✔ Méthodes avec valeur retournée
Elles simplifient l'accès aux données de l’objet :
```java
public boolean estRapide() {
return vitesse > 100;
}
```
# đźź« 5. Constructeurs
Les constructeurs servent à **initialiser correctement** les objets lors de leur création.
```java
public class Voiture {
private int vitesse;
public Voiture() {
vitesse = 0;
}
}
```
### âś” Pourquoi un constructeur ?
- il impose un état initial cohérent,
- il évite des objets “vides” ou incohérents,
- il automatise la préparation de l’objet.
### ✔ Constructeur avec paramètres
```java
public Voiture(String m) {
marque = m;
vitesse = 0;
}
```
Cela permet de créer un objet déjà configuré.
### âś” Constructeurs multiples
```java
public Voiture() {
}
public Voiture(String m) {
marque = m;
}
public Voiture(String m, int v) {
marque = m;
vitesse = v;
}
```
➡️ C’est la **surcharge des constructeurs**.
Elle permet de créer différents types d’objets selon les besoins.
# 🟨 6. Constructeur par défaut
Par défaut, si aucun constructeur n’est écrit, Java crée :
```java
public Voiture() {
}
```
Mais **dès qu'un constructeur est défini**, Java _ne génère plus_ le constructeur vide.
# 🟦 7. Le mot-clé `this`
`this` représente **l’objet courant**, celui qui exécute la méthode.
### ✔ Différencier attribut / paramètre
```java
void setVitesse(int vitesse)
{
this.vitesse = vitesse;
}```
'this.vitesse' fait référence à l'attribut `vitesse` de `this`, l'objet courant.
### âś” Appeler un autre constructeur
C’est un mécanisme très utile pour éviter de dupliquer du code.
```java
public Voiture() {
this("Renault");
}
```
Ici, nous faisons appel Ă ce constructeur :
```java
public Voiture(String m) {
marque = m;
vitesse = 0;
}
```
# 🟥 8. Création et utilisation des objets
### âś” DĂ©claration
```java
Voiture v;
```
### âś” Construction (instanciation)
```java
v = new Voiture();
```
### âś” Utilisation
```java
v.demarrer();
v.accelerer();
int x = v.getVitesse();
```
Un objet est manipulé via sa **référence** (stockée dans la variable `v`).
# 🟫 9. Cycle de vie d’un objet
Voici les différentes étapes du cycle de vie d'un objet :
1. **DĂ©claration**
2. **Construction** (appel d'un constructeur)
3. **Utilisation** (appel de méthodes)
4. **Perte de référence** (ex. : `v = null;`)
# 🟪 10. Affectation et comparaison d’objets
### âś” Affectation
```java
Voiture v1 = new Voiture();
Voiture v2 = v1;
```
Les deux variables pointent vers **le mĂŞme objet**.
### âś” Comparaison
- `==` → compare les **références** (même objet ?)
- `equals()` → compare le **contenu**, mais uniquement si redéfini
C’est un piège courant pour les débutants.
# 🟧 11. Rigueur et bonne conception
Une classe bien conçue doit :
- avoir des attributs privés,
- proposer des méthodes publiques,
- initialiser son Ă©tat via les constructeurs.
# 🗓️ Historique
> Dernière mise à jour : 22 novembre 2025
> Rédigé par : [[Julien DUQUENNOY]]