Gestion des etudiant
//[Link]
import [Link];
import [Link];
/**
* Programme simple de gestion des étudiants
* Tout est dans un seul fichier [Link]
*/
public class Main {
/**
* Classe Etudiant (modèle)
* Représente un étudiant avec id, nom et âge
*/
static class Etudiant {
int id;
String nom;
int age;
// Constructeur
public Etudiant(int id, String nom, int age) {
[Link] = id;
[Link] = nom;
[Link] = age;
}
// Méthode pour afficher un étudiant
public void afficher() {
[Link]("ID: " + id + ", Nom: " + nom + ", Age: " + age);
}
}
public static void main(String[] args) {
// Liste qui va stocker les étudiants
ArrayList<Etudiant> liste = new ArrayList<>();
// Scanner pour lire les entrées utilisateur
Scanner sc = new Scanner([Link]);
int choix;
do {
// Menu principal
[Link]("\n===== MENU =====");
[Link]("1. Ajouter un étudiant");
[Link]("2. Afficher tous les étudiants");
[Link]("3. Rechercher un étudiant");
[Link]("4. Supprimer un étudiant");
[Link]("0. Quitter");
[Link]("Votre choix : ");
choix = [Link]();
switch (choix) {
case 1:
// Ajouter un étudiant
[Link]("ID : ");
int id = [Link]();
[Link](); // consommer le retour ligne
[Link]("Nom : ");
String nom = [Link]();
[Link]("Age : ");
int age = [Link]();
// Création et ajout
Etudiant e = new Etudiant(id, nom, age);
[Link](e);
[Link]("Étudiant ajouté !");
break;
case 2:
// Afficher tous les étudiants
if ([Link]()) {
[Link]("Aucun étudiant.");
} else {
[Link]("Liste des étudiants :");
for (Etudiant et : liste) {
[Link]();
}
}
break;
case 3:
// Rechercher un étudiant par ID
[Link]("Entrer ID à rechercher : ");
int idRecherche = [Link]();
boolean trouve = false;
for (Etudiant et : liste) {
if ([Link] == idRecherche) {
[Link]("Étudiant trouvé :");
[Link]();
trouve = true;
break;
}
}
if (!trouve) {
[Link]("Étudiant non trouvé.");
}
break;
case 4:
// Supprimer un étudiant par ID
[Link]("Entrer ID à supprimer : ");
int idSup = [Link]();
boolean supprime = false;
for (Etudiant et : liste) {
if ([Link] == idSup) {
[Link](et);
[Link]("Étudiant supprimé !");
supprime = true;
break;
}
}
if (!supprime) {
[Link]("Étudiant non trouvé.");
}
break;
case 0:
[Link]("Au revoir !");
break;
default:
[Link]("Choix invalide !");
}
} while (choix != 0);
[Link]();
}
}
Etapes pour coder
0. Structure du projet
gestion-etudiants/
│── [Link]
│── [Link]
Jour 1 — Structure de base + Menu
Objectif : comprendre le squelette du programme
• Créer [Link]
• Ajouter le menu
• Gérer les choix utilisateur (sans logique métier)
Initialisation du projet Git
Tu te places dans ton dossier :
cd gestion-etudiants
🔹 Initialiser Git
git init
Résultat :
Git commence à suivre ton projet
🔹 Vérifier l’état
git status
Tu verras :
[Link] (untracked)
🔹 Ajouter ton fichier
git add [Link]
Ou tout ajouter :
git add .
🔹 Premier commit
git commit -m "Jour 1: menu de base sans logique métier"
Ajouter README (bonne pratique)
touch [Link]
git add [Link]
git commit -m "Ajout README du projet"
Code à ajouter dans [Link]
import [Link];
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
int choix;
do {
[Link]("\n===== MENU =====");
[Link]("1. Ajouter");
[Link]("2. Afficher");
[Link]("3. Rechercher");
[Link]("4. Supprimer");
[Link]("0. Quitter");
[Link]("Choix : ");
choix = [Link]();
switch (choix) {
case 1:
[Link]("Ajouter (pas encore implémenté)");
break;
case 2:
[Link]("Afficher (pas encore implémenté)");
break;
case 3:
[Link]("Rechercher (pas encore implémenté)");
break;
case 4:
[Link]("Supprimer (pas encore implémenté)");
break;
}
} while (choix != 0);
[Link]();
}
}
Comment corriger un mauvais commit ?
IDÉE GÉNÉRALE
-Un commit n’est pas forcément définitif
- Tu peux le modifier… mais attention comment
CAS 1 : Corriger le dernier commit (git
amend)
Situation 1 : mauvais message
Tu fais :
git commit -m "modif"
Pas clair du tout
Solution
git commit --amend -m "Ajout de la page d'accueil"
Résultat :
• Le commit est corrigé
• L’historique devient propre
Image simple
--amend = “corriger le dernier commit”
Situation 2 : tu as oublié un fichier
Tu fais :
git add [Link]
git commit -m "Ajout index"
Oups… tu as oublié [Link]
Solution
git add [Link]
git commit --amend --no-edit
Explication
• --no-edit = garder le même message
• Git va ajouter le fichier au commit précédent
Résultat
Au lieu de 2 commits → 1 seul propre
⚠️ ATTENTION (TRÈS IMPORTANT)
N’utilise PAS --amend si tu as déjà fait :
git push (À étudier
plus tard)
Sinon tu casses l’historique partagé
Jour 2 — Classe Etudiant
Objectif : créer ton modèle (les données)
Ce que tu ajoutes
• Classe Etudiant
• Attributs + constructeur
Ajouter classe Etudiant
Tu modifies [Link]
🔹 Voir les modifications
git status
git diff
🔹 Ajouter et commit
git add [Link]
git commit -m "Jour 2: ajout classe Etudiant"
Ajouter ce code
static class Etudiant {
int id;
String nom;
int age;
public Etudiant(int id, String nom, int age) {
[Link] = id;
[Link] = nom;
[Link] = age;
}
public void afficher() {
[Link]("ID: " + id + ", Nom: " + nom + ", Age: " + age);
}
}
Jour 3 — Stockage (ArrayList)
Objectif : créer une mémoire pour les étudiants
git add [Link]
git commit -m "Jour 3: ajout stockage avec ArrayList"
Ce qu’on ajoute
import [Link];
// dans main()
ArrayList<Etudiant> liste = new ArrayList<>();
Là onvient de créer notre mini base de données en mémoire
Jour 4 — Ajouter un étudiant
Objectif : première vraie fonctionnalité (CREATE)
git add [Link]
git commit -m "Jour 4: implémentation ajout étudiant"
Code à mettre dans case 1
[Link]("ID : ");
int id = [Link]();
[Link]();
[Link]("Nom : ");
String nom = [Link]();
[Link]("Age : ");
int age = [Link]();
Etudiant e = new Etudiant(id, nom, age);
[Link](e);
[Link]("Étudiant ajouté !");
Jour 5 — Afficher les étudiants
Objectif : lire les données (READ)
git add [Link]
git commit -m "Jour 5: affichage des étudiants"
Code (case 2)
if ([Link]()) {
[Link]("Aucun étudiant.");
} else {
for (Etudiant et : liste) {
[Link]();
}
}
Jour 6 — Rechercher un étudiant
Objectif : comprendre les conditions + boucle
git add [Link]
git commit -m "Jour 6: recherche étudiant par ID"
Code (case 3)
[Link]("ID à rechercher : ");
int idRecherche = [Link]();
boolean trouve = false;
for (Etudiant et : liste) {
if ([Link] == idRecherche) {
[Link]();
trouve = true;
break;
}
}
if (!trouve) {
[Link]("Non trouvé");
}
Jour 7 — Supprimer un étudiant
Objectif : modifier les données (DELETE)
git add [Link]
git commit -m "Jour 7: suppression étudiant"
Code (case 4)
[Link]("ID à supprimer : ");
int idSup = [Link]();
boolean supprime = false;
for (Etudiant et : liste) {
if ([Link] == idSup) {
[Link](et);
supprime = true;
[Link]("Supprimé !");
break;
}
}
if (!supprime) {
[Link]("Non trouvé");
}
Récap. logique (important)
Notre programme évolue comme ça :
1. Menu → interaction
2. Modèle → données (Etudiant)
3. Liste → stockage
4. CRUD :
• Create → ajouter
• Read → afficher
• Update → (on ne l’a pas encore fait)
• Delete → supprimer
Voir l’historique
git log
Version courte :
git log --oneline
10. Revenir en arrière (time travel )
🔹 Voir ancienne version
git checkout <id_commit>
Exemple :
git checkout a1b2c3
🔹 Revenir à la dernière version
git checkout main
Créer des branches (comme en entreprise)
Nouvelle fonctionnalité → branche
git branch feature-update
git checkout feature-update
OU directement :
git checkout -b feature-update
12. Travailler sur la branche
Exemple : ajouter UPDATE
git add [Link]
git commit -m "Feature: modification étudiant"
Ajouter une option dans le menu
Modifie le menu :
[Link]("5. Modifier un étudiant");
Ajouter le case 5 (UPDATE)
Code à mettre dans le switch
case 5:
[Link]("ID à modifier : ");
int idModif = [Link]();
[Link](); // vider buffer
boolean modifie = false;
for (Etudiant et : liste) {
if ([Link] == idModif) {
[Link]("Nouveau nom : ");
String nouveauNom = [Link]();
[Link]("Nouvel age : ");
int nouvelAge = [Link]();
// Mise à jour
[Link] = nouveauNom;
[Link] = nouvelAge;
[Link]("Étudiant modifié !");
modifie = true;
break;
}
}
if (!modifie) {
[Link]("Étudiant non trouvé.");
}
break;
Fusionner (merge)
git checkout main (vous verrez une erreur)
Pourquoi cette erreur ?
error: Vos modifications locales ... seraient écrasées
Traduction simple :
"Tu as modifié [Link], mais tu veux changer de branche.
Si je change de branche, je vais écraser tes modifications.
Donc je refuse pour protéger ton travail."
Situation actuelle
Tu es sur une branche (ou commit)
Tu as modifié [Link]
Tu n’as PAS fait git commit
Git bloque pour éviter une perte de données
SOLUTIONS
1. Sauvegarder
Tu veux garder ton travail
git add .
git commit -m "travail en cours"
git checkout main
- Solution propre
-Rien n’est perdu
2. Mettre de côté (stash)
Tu n’es pas prêt à commit
git stash
git checkout main
Pour récupérer :
git stash pop
Cas réel :
• tu testes un truc
• tu veux changer de branche rapidement
3. Supprimer les modifications (danger ⚠️)
Tu veux tout annuler
git checkout -- [Link]
git checkout main
OU
git reset --hard
git checkout main
Tout est perdu
Maintenant ,on peut merger notre travaille
git merge feature-update
puis supprimer la branche : git branch -d feature-update
Annuler des modifications
🔹 Annuler fichier modifié
git checkout – [Link]
Ce que ça fait
Supprime les modifications non enregistrées
Working directory → supprimé
Staging → inchangé
Commit → intact
Exemple
Tu modifies :
[Link]("Erreur");
Tu veux revenir comme avant :
git checkout -- [Link]
Ton code redevient comme au dernier commit
⚠️ Important
Tu perds tes modifications définitivement
🔹 Désindexer (retirer du git add)
git reset [Link]
Annuler dernier commit (soft)
git reset --soft HEAD~1
Ce que ça fait
Supprime le commit MAIS garde ton code
Working
Staging
Commit → supprimé
Exemple
Tu fais :
git commit -m "mauvais commit"
Tu corriges :
git reset --soft HEAD~1
Résultat :
ton code est toujours là
prêt à recommit
Annuler complètement (danger ⚠️)
git reset --hard HEAD~1
Ce que ça fait
Supprime TOUT :
Working
Staging
Commit
Retour total au commit précédent
Exemple
git commit -m "bug énorme"
Tu veux effacer :
git reset --hard HEAD~1
Comme si ce commit n’avait jamais existé
ATTENTION
--hard = destruction définitive
NB :
Aujourd’hui on préfère (version moderne):
git restore [Link]
git restore --staged [Link]
Voir qui a fait quoi
git blame [Link]
Sauvegarder une version (tag)
git tag v1.0
git tag
C’est quoi un tag ?
Un tag = une étiquette sur un commit
Exemple :
A --- B --- C --- D
↑
v1.0
Ici :
• v1.0 pointe vers le commit C
• Ça représente une version stable
Créer un tag
git tag v1.0
Ce que ça fait
Git dit :
“ce commit actuel = version 1.0”
Exemple réel
Tu finis ton projet :
git commit -m "Projet terminé"
Tu marques la version :
git tag v1.0
Voir les tags
git tag
Résultat :
v1.0
v1.1
v2.0
Voir les détails d’un tag
git show v1.0
Tu vois :
• le commit
• le message
• les changements
Tag sur un ancien commit
Tu peux taguer une ancienne version :
git log --oneline
git tag v0.9 abc123
Là :
• abc123 = ancien commit
Aller sur un tag
git checkout v1.0
Tu reviens à cette version
⚠️ même problème :
tu es en detached HEAD
Bonne pratique
Si tu veux travailler dessus :
git checkout -b test-v1 v1.0
Types de tags (important)
🔹 Tag simple (lightweight)
git tag v1.0
simple pointeur
🔹 Tag annoté
git tag -a v1.0 -m "Version stable du projet"
contient :
• auteur
• date
• message
Supprimer un tag
git tag -d v1.0
RéCAP.
Commande Rôle
git tag v1.0 créer version
git tag lister
git show v1.0 voir détails
git tag v1.0 <id> tag ancien commit
git tag -d v1.0 supprimer
Image mentale
commit = sauvegarde
tag = “version officielle”
Cas réel en entreprise
Exemple :
v1.0 → version initiale
v1.1 → bug corrigé
v2.0 → nouvelle fonctionnalité
Conseil PRO
Toujours taguer :
• une version stable
• avant déploiement
• avant modification risquée
.gitignore (propre)
Créer fichier :
touch .gitignore
Contenu :
*.class
*.log
git add .gitignore
git commit -m "Ajout gitignore"
Prochaine étape plus tard :
Le fork sur GitHub,
🔹 1. C’est quoi un fork
Un fork, c’est une copie d’un projet qui ne t’appartient pas que tu mets dans ton propre compte
GitHub.
Imagine :
• Quelqu’un a un projet (ex : une app Java)
• Tu veux modifier ce projet
• MAIS tu n’as pas le droit de modifier directement
Donc tu fais un fork = copier le projet chez toi
🔹 2. Exemple concret
Supposons :
• Projet original : [Link]/tchatcha/app-gestion
• Tu fais un fork
Résultat :
• Tu obtiens : [Link]/toi/app-gestion
C’est le même projet, mais maintenant c’est le tien
🔹 3. Pourquoi on utilise fork ?
Cas 1 : Modifier sans casser l’original
Tu peux tester, casser, modifier… sans problème
Cas 2 : Contribuer à un projet
Tu modifies ton fork puis tu proposes les changements à l’auteur
ça s’appelle une Pull Request (PR)
🔹 4. Workflow complet (très important)
Voici le vrai processus utilisé dans la pratique
Étape 1 : Fork sur GitHub
Tu vas sur le projet
Tu cliques sur Fork
GitHub crée une copie dans ton compte
Étape 2 : Cloner ton fork en local
git clone [Link]
cd app-gestion
Étape 3 : Ajouter le projet original (upstream)
Très important pour suivre les mises à jour
git remote add upstream [Link]
Vérifier :
git remote -v
Étape 4 : Créer une branche
git checkout -b ma-modification
Étape 5 : Modifier le code
Tu fais tes changements normalement
Étape 6 : Commit + push
git add .
git commit -m "Ajout fonctionnalité X"
git push origin ma-modification
Étape 7 : Pull Request (PR)
Sur GitHub :
• Tu cliques sur Compare & Pull Request
• Tu proposes tes modifications au projet original
🔹 5. Fork vs Clone (ne pas confondre)
Action Signification
Fork Copier sur GitHub
Clone Copier sur ton ordinateur
Donc :
• Fork = en ligne
• Clone = en local
🔹 6. Upstream (très important)
Le projet original continue d’évoluer
Donc tu dois synchroniser :
git fetch upstream
git merge upstream/main
Ça permet de récupérer les nouvelles modifications
🔹 7. Schéma simple
Projet original (tchatcha)
↓ fork
Ton repo GitHub
↓ clone
Ton PC
↓ modif
Push → Ton repo
↓
Pull Request → Projet original
🔹 8. Cas réel
Tu vois un projet open source :
• Tu trouves un bug
• Tu veux corriger
Tu fais :
1. Fork
2. Clone
3. Correction
4. Push
5. Pull Request
L’auteur peut :
• accepter
• refuser
• demander modification
Récap.
Fork = copier un projet GitHub chez toi pour travailler dessus