Support de Cours Java — POO & MySQL | SIL 2ème Année

UNIVERSITÉ
Département Système Informatique et Logiciel

SUPPORT DE COURS

Programmation Java — POO & Bases de Données

Deuxième Année
Cours Magistraux · Travaux Pratiques · Exercices Corrigés

IDE : NetBeans · Base de données : MySQL · JDK 17+

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

CM1 — Introduction au langage Java

1. Qu'est-ce que Java ?
Java est un langage de programmation orienté objet, créé par Sun Microsystems en 1995. Il est
aujourd'hui l'un des langages les plus utilisés au monde, notamment dans les applications
d'entreprise, les applications Android et les systèmes embarqués.

Philosophie Java

Write Once, Run Anywhere (WORA) : un programme Java compilé s'exécute sur toute
machine disposant de la JVM.

Java est fortement typé : chaque variable a un type défini à la compilation.

La gestion de la mémoire est automatique grâce au Garbage Collector.

2. Architecture Java : JDK, JRE, JVM

Composant Rôle

JDK (Java Development Kit) Environnement de développement complet : compilateur

(javac), bibliothèques, outils de débogage

JRE (Java Runtime Environment) Environnement d'exécution : JVM + bibliothèques

standards

JVM (Java Virtual Machine) Machine virtuelle qui exécute le bytecode Java sur
n'importe quel système d'exploitation

3. Types primitifs

Type Taille Valeurs

int 32 bits Entiers : -2 147 483 648 à 2 147 483 647

double 64 bits Nombres décimaux à virgule flottante

boolean 1 bit true ou false

char 16 bits Un seul caractère Unicode

long 64 bits Grands entiers

String Objet Chaîne de caractères (pas primitif mais très utilisé)

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

4. Premier programme Java

Tout programme Java contient une classe principale et une méthode main qui est le point d'entrée
de l'application.

public class Bonjour {

public static void main(String[] args) {
// Affichage dans la console
[Link]("Bonjour, étudiants SIL !");

// Variables
int age = 20;
double moyenne = 14.5;
String nom = "Alice";

[Link]("Nom : " + nom + ", Age : " + age);

}
}

5. Structures de contrôle
5.1 Condition if/else
int note = 12;
if (note >= 10) {
[Link]("Admis");
} else if (note >= 8) {
[Link]("Rattrapage");
} else {
[Link]("Refusé");
}

5.2 Boucle for

// Afficher les nombres de 1 à 5
for (int i = 1; i <= 5; i++) {
[Link]("Nombre : " + i);
}

5.3 Boucle while

int compteur = 0;
while (compteur < 3) {
[Link]("Tour : " + compteur);
compteur++;
}

6. Méthodes
Une méthode est un bloc de code réutilisable qui effectue une tâche précise. Elle peut recevoir des
paramètres et retourner un résultat.
public class Calculs {
// Méthode qui retourne la somme de deux entiers
public static int additionner(int a, int b) {
return a + b;

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

// Méthode sans retour (void)

public static void afficherBonjour(String prenom) {
[Link]("Bonjour " + prenom + " !");
}

public static void main(String[] args) {

int resultat = additionner(5, 3);
[Link]("5 + 3 = " + resultat);
afficherBonjour("Koffi");
}
}

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

TP1 — Prise en main de NetBeans et bases Java

Objectifs du TP

Installer et configurer NetBeans avec le JDK 17.

Connecter MySQL dans l'onglet Services de NetBeans.

Créer et exécuter ses premiers programmes Java.

Partie 1 — Installation et configuration

1. Télécharger et installer le JDK 17 depuis [Link]
2. Télécharger Apache NetBeans depuis [Link]
3. Installer MySQL Server et noter le mot de passe root lors de l'installation.
4. Dans NetBeans : menu Fenêtre → Services → Bases de données → Nouvelle connexion →
choisir MySQL.

Partie 2 — Exercices

Exercice 1 — Hello World

Créez un nouveau projet Java dans NetBeans nommé TP1.

Dans la classe principale, affichez votre nom, prénom et filière.

Compilez et exécutez le programme.

// Exemple de solution attendue :

public class Main {
public static void main(String[] args) {
[Link]("Nom : Dupont");
[Link]("Prénom : Jean");
[Link]("Filière: SIL 2");
}
}

Exercice 2 — Calculatrice simple

Écrivez une méthode pour chaque opération : addition, soustraction, multiplication,

division.

Appelez chaque méthode depuis le main avec les valeurs 10 et 4.

Gérez la division par zéro avec un message d'erreur approprié.

Corrigé
public class Calculatrice {
public static int addition(int a, int b) { return a + b; }

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

public static int soustraction(int a, int b) { return a - b; }

public static int multiplication(int a, int b) { return a * b; }
public static double division(int a, int b) {
if (b == 0) {
[Link]("Erreur : division par zéro !");
return 0;
}
return (double) a / b;
}
public static void main(String[] args) {
[Link]("10 + 4 = " + addition(10, 4));
[Link]("10 - 4 = " + soustraction(10, 4));
[Link]("10 x 4 = " + multiplication(10, 4));
[Link]("10 / 4 = " + division(10, 4));
}
}

Exercice 3 — Tableau de notes

Déclarez un tableau de 5 notes entières.

Écrivez une méthode calculerMoyenne(int[] notes) qui retourne la moyenne.

Écrivez une méthode trouverMax(int[] notes) qui retourne la note maximale.

Affichez la moyenne et le maximum dans le main.

Corrigé
public class Notes {
public static double calculerMoyenne(int[] notes) {
int somme = 0;
for (int n : notes) somme += n;
return (double) somme / [Link];
}
public static int trouverMax(int[] notes) {
int max = notes[0];
for (int n : notes) if (n > max) max = n;
return max;
}
public static void main(String[] args) {
int[] notes = {12, 15, 9, 18, 11};
[Link]("Moyenne : " + calculerMoyenne(notes));
[Link]("Maximum : " + trouverMax(notes));
}
}

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

CM2 — Classes et Objets

1. Concepts fondamentaux de la POO
La Programmation Orientée Objet repose sur quatre piliers : l'Encapsulation, l'Héritage, le
Polymorphisme et l'Abstraction. Dans ce chapitre, nous allons voir les deux premiers concepts
fondamentaux : les classes et les objets.

Analogie essentielle

Une CLASSE est un moule, un plan de construction.

Un OBJET est une instance concrète créée à partir de ce moule.

Exemple : Etudiant est une classe. Koffi Mensah (23 ans, SIL) est un objet de cette
classe.

2. Structure d'une classe

public class Etudiant {
// ── Attributs (état de l'objet) ──
private String nom;
private String prenom;
private int age;
private double moyenne;

// ── Constructeur ──
public Etudiant(String nom, String prenom, int age) {
[Link] = nom;
[Link] = prenom;
[Link] = age;
[Link] = 0.0;
}

// ── Getters ──
public String getNom() { return nom; }
public String getPrenom() { return prenom; }
public int getAge() { return age; }
public double getMoyenne() { return moyenne; }

// ── Setters ──
public void setMoyenne(double moyenne) {
if (moyenne >= 0 && moyenne <= 20)
[Link] = moyenne;
}

// ── Méthode toString ──
@Override
public String toString() {
return "Etudiant[" + nom + " " + prenom + ", age=" + age

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

+ ", moyenne=" + moyenne + "]";

}
}

3. Instanciation et utilisation
public class Main {
public static void main(String[] args) {
// Créer des objets
Etudiant e1 = new Etudiant("Mensah", "Koffi", 21);
Etudiant e2 = new Etudiant("Agbovi", "Ama", 20);

// Modifier les attributs via les setters

[Link](14.5);
[Link](16.0);

// Afficher les objets

[Link](e1);
[Link](e2);
[Link]("Meilleur étudiant : " + [Link]());
}
}

4. Encapsulation
L'encapsulation consiste à protéger les attributs d'une classe en les déclarant privés (private) et en
fournissant des méthodes publiques pour y accéder et les modifier. Cela garantit l'intégrité des
données.

Modificateur Accès

private Accessible uniquement dans la classe elle-même

public Accessible depuis n'importe quelle classe

protected Accessible dans la classe et ses sous-classes

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

TP2 — Modélisation de classes

Objectifs du TP

Créer des classes Java avec attributs, constructeurs et méthodes.

Appliquer le principe d'encapsulation (private + getters/setters).

Instancier des objets et les manipuler.

Exercice 1 — Classe Professeur

Créez une classe Professeur avec les attributs : nom (String), prenom (String), matiere
(String), salaireBase (double).

Ajoutez un constructeur prenant les 4 paramètres.

Ajoutez des getters pour tous les attributs et un setter pour salaireBase (valeur > 0
obligatoire).

Ajoutez une méthode calculerSalaireNet() qui retourne salaireBase * 0.85 (après

déduction).

Ajoutez une méthode toString() affichant toutes les informations.

Dans le main, créez 2 professeurs et affichez leur salaire net.

Corrigé
public class Professeur {
private String nom, prenom, matiere;
private double salaireBase;

public Professeur(String nom, String prenom, String matiere, double

salaireBase) {
[Link] = nom; [Link] = prenom;
[Link] = matiere; [Link] = salaireBase;
}
public String getNom() { return nom; }
public String getPrenom() { return prenom; }
public String getMatiere(){ return matiere; }
public void setSalaireBase(double s) { if (s > 0) salaireBase = s; }
public double calculerSalaireNet() { return salaireBase * 0.85; }
@Override
public String toString() { return prenom+" "+nom+" ("+matiere+") - Net:
"+calculerSalaireNet(); }
public static void main(String[] args) {
Professeur p1 = new Professeur("Komi","Théodore","Java",350000);
Professeur p2 = new Professeur("Adzoa","Séraphine","BDD",400000);

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

[Link](p1);
[Link](p2);
}
}

Exercice 2 — Classe Cours

Créez une classe Cours avec : code (String), intitule (String), credits (int), volumeHoraire
(int).

Constructeur complet + getters/setters.

Méthode estValidant() : retourne true si credits >= 2.

Méthode toString() complète.

Créez 3 cours et affichez ceux qui sont validants.

Corrigé
public class Cours {
private String code, intitule;
private int credits, volumeHoraire;

public Cours(String code, String intitule, int credits, int vh) {

[Link]=code; [Link]=intitule;
[Link]=credits; [Link]=vh;
}
public String getCode() { return code; }
public String getIntitule(){ return intitule; }
public int getCredits() { return credits; }
public boolean estValidant(){ return credits >= 2; }
@Override
public String toString() { return code+" - "+intitule+" ("+credits+"
crédits)"; }
public static void main(String[] args) {
Cours[] cours = { new Cours("INF201","Java",3,30),
new Cours("INF202","BDD",3,25),
new Cours("INF203","Algo",1,15) };
for (Cours c : cours)
if ([Link]()) [Link](c + " => VALIDANT");
}
}

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

CM3 — Héritage, Polymorphisme et Collections

1. Héritage
L'héritage permet à une classe (sous-classe) de réutiliser les attributs et méthodes d'une autre
classe (super-classe). On utilise le mot-clé extends.
// Super-classe
public class Personne {
protected String nom;
protected String prenom;
protected int age;

public Personne(String nom, String prenom, int age) {

[Link] = nom; [Link] = prenom; [Link] = age;
}
public String getNomComplet() { return prenom + " " + nom; }
public String toString() { return getNomComplet() + " (" + age + " ans)"; }
}

// Sous-classe Etudiant hérite de Personne

public class Etudiant extends Personne {
private String matricule;
private double moyenne;

public Etudiant(String nom, String prenom, int age, String matricule) {

super(nom, prenom, age); // Appel du constructeur parent
[Link] = matricule;
[Link] = 0.0;
}
public String getMatricule() { return matricule; }
public void setMoyenne(double m) { [Link] = m; }
@Override
public String toString() {
return [Link]() + " | Matricule: " + matricule
+ " | Moyenne: " + moyenne;
}
}

2. Polymorphisme
Le polymorphisme permet d'utiliser une référence de type parent pour désigner un objet de type
enfant. La méthode appelée est déterminée à l'exécution selon le type réel de l'objet.
Personne p1 = new Etudiant("Mensah","Koffi",21,"SIL2023-01");
Personne p2 = new Professeur("Komi","Théodore",45,"Java");

// Appel polymorphe : toString() de chaque sous-classe est appelé

[Link]([Link]());
[Link]([Link]());

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

3. Classes abstraites et interfaces

// Classe abstraite : ne peut pas être instanciée directement
public abstract class Personne {
protected String nom;
// Méthode abstraite : chaque sous-classe doit l'implémenter
public abstract String getRole();
}

// Interface
public interface Evaluable {
double calculerNote();
boolean estAdmis();
}

// Classe concrète implémente l'interface

public class Etudiant extends Personne implements Evaluable {
private double moyenne;
@Override public String getRole() { return "Etudiant"; }
@Override public double calculerNote() { return moyenne; }
@Override public boolean estAdmis() { return moyenne >= 10; }
}

4. Collections : ArrayList et HashMap

import [Link];
import [Link];

// ArrayList : liste dynamique d'objets

ArrayList<Etudiant> promotion = new ArrayList<>();
[Link](new Etudiant("Mensah","Koffi",21,"SIL-001"));
[Link](new Etudiant("Agbovi","Ama",20,"SIL-002"));

// Parcourir la liste
for (Etudiant e : promotion) {
[Link](e);
}

// HashMap : association clé → valeur

HashMap<String, Double> notes = new HashMap<>();
[Link]("SIL-001", 14.5);
[Link]("SIL-002", 16.0);
[Link]([Link]("SIL-001")); // Affiche 14.5

5. Gestion des exceptions

public double diviser(double a, double b) {
if (b == 0) throw new ArithmeticException("Division par zéro !");
return a / b;
}

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

try {
double res = diviser(10, 0);
} catch (ArithmeticException e) {
[Link]("Erreur : " + [Link]());
} finally {
[Link]("Bloc finally toujours exécuté.");
}

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

TP3 — Héritage et Polymorphisme en pratique

Objectifs du TP

Mettre en place une hiérarchie de classes avec héritage.

Utiliser le polymorphisme avec des ArrayList.

Gérer les exceptions dans un contexte réel.

Exercice 1 — Hiérarchie Personne → Etudiant / Professeur

Créez la classe abstraite Personne (nom, prenom, age) avec une méthode abstraite
getRole().

Créez Etudiant extends Personne avec : matricule, moyenne. Implémente getRole() →

'Etudiant'.

Créez Professeur extends Personne avec : specialite, salaire. Implémente getRole() →

'Professeur'.

Dans le main, créez une ArrayList<Personne> avec 3 étudiants et 2 professeurs.

Parcourez la liste et affichez le rôle et les informations de chaque personne.

Corrigé
// [Link]
public abstract class Personne {
protected String nom, prenom; protected int age;
public Personne(String n, String p, int a){nom=n;prenom=p;age=a;}
public abstract String getRole();
public String toString(){return getRole()+" : "+prenom+" "+nom;}
}
// [Link]
public class Etudiant extends Personne {
private String matricule; private double moyenne;
public Etudiant(String n,String p,int a,String m){super(n,p,a);matricule=m;}
public String getRole(){return "Etudiant";}
public void setMoyenne(double m){moyenne=m;}
public String toString(){return [Link]()+" | "+matricule+" |
"+moyenne+"/20";}
}
// [Link]
public class Professeur extends Personne {
private String specialite; private double salaire;
public Professeur(String n,String p,int a,String s,double sal)
{super(n,p,a);specialite=s;salaire=sal;}

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

public String getRole(){return "Professeur";}

public String toString(){return [Link]()+" | "+specialite;}
}
// [Link]
import [Link];
public class Main {
public static void main(String[] args) {
ArrayList<Personne> liste = new ArrayList<>();
[Link](new Etudiant("Mensah","Koffi",21,"SIL-001"));
[Link](new Etudiant("Agbovi","Ama",20,"SIL-002"));
[Link](new Professeur("Komi","Théodore",45,"Java",350000));
for (Personne p : liste) [Link](p);
}
}

Exercice 2 — Gestion d'exceptions personnalisée

Créez une exception NoteInvalideException extends Exception.

Modifiez le setter setMoyenne() de la classe Etudiant pour lever cette exception si la

note est hors de [0, 20].

Dans le main, gérez cette exception avec try/catch et affichez un message clair.

Corrigé
// [Link]
public class NoteInvalideException extends Exception {
public NoteInvalideException(double note) {
super("Note invalide : " + note + " (doit être entre 0 et 20)");
}
}
// Dans [Link] :
public void setMoyenne(double m) throws NoteInvalideException {
if (m < 0 || m > 20) throw new NoteInvalideException(m);
[Link] = m;
}
// Dans [Link] :
try {
[Link](25); // Valeur invalide
} catch (NoteInvalideException e) {
[Link]("Erreur : " + [Link]());
}

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

CM4 — Connexion Java ↔ MySQL avec JDBC

1. Qu'est-ce que JDBC ?
JDBC (Java Database Connectivity) est l'API standard de Java pour se connecter à des bases de
données relationnelles. Elle fournit un ensemble d'interfaces permettant d'exécuter des requêtes
SQL depuis du code Java, indépendamment du SGBD utilisé.

Étapes JDBC à retenir

1. Charger le pilote (Driver) : [Link]("[Link]")

2. Établir la connexion : [Link](url, user, password)

3. Créer un Statement ou PreparedStatement

4. Exécuter la requête SQL

5. Traiter le ResultSet (pour les SELECT)

6. Fermer les ressources (ResultSet, Statement, Connection)

2. Ajouter le pilote MySQL dans NetBeans

Téléchargez le fichier [Link] depuis
[Link]
Dans NetBeans : clic droit sur votre projet → Propriétés → Bibliothèques → Ajouter le JAR.

3. Classe de connexion réutilisable

import [Link];
import [Link];
import [Link];

public class ConnexionMySQL {

private static final String URL = "jdbc:mysql://localhost:3306/ecole";
private static final String USER = "root";
private static final String PASS = "votre_mot_de_passe";

public static Connection getConnexion() throws SQLException {

return [Link](URL, USER, PASS);
}
}

4. Opérations CRUD avec JDBC

4.1 INSERT — Ajouter un enregistrement
String sql = "INSERT INTO etudiants (nom, prenom, age) VALUES (?, ?, ?)";
try (Connection conn = [Link]();

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

PreparedStatement ps = [Link](sql)) {
[Link](1, "Mensah");
[Link](2, "Koffi");
[Link](3, 21);
int lignes = [Link]();
[Link](lignes + " ligne(s) insérée(s)");
} catch (SQLException e) {
[Link]("Erreur : " + [Link]());
}

4.2 SELECT — Lire les données

String sql = "SELECT * FROM etudiants";
try (Connection conn = [Link]();
PreparedStatement ps = [Link](sql);
ResultSet rs = [Link]()) {
while ([Link]()) {
int id = [Link]("id");
String nom = [Link]("nom");
String prenom= [Link]("prenom");
int age = [Link]("age");
[Link](id + " - " + prenom + " " + nom + " (" + age + " ans)");
}
} catch (SQLException e) {
[Link]("Erreur : " + [Link]());
}

4.3 UPDATE et DELETE

// UPDATE
String sqlUpdate = "UPDATE etudiants SET age = ? WHERE id = ?";
try (Connection conn = [Link]();
PreparedStatement ps = [Link](sqlUpdate)) {
[Link](1, 22);
[Link](2, 1);
[Link]();
}

// DELETE
String sqlDelete = "DELETE FROM etudiants WHERE id = ?";
try (Connection conn = [Link]();
PreparedStatement ps = [Link](sqlDelete)) {
[Link](1, 1);
[Link]();
}

Sécurité — Pourquoi utiliser PreparedStatement ?

Ne JAMAIS construire une requête SQL par concaténation de chaînes.

Exemple dangereux : "SELECT * FROM users WHERE nom = '" + nom + "'"

Si nom = "' OR '1'='1" → injection SQL, accès à toutes les données !

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

PreparedStatement protège automatiquement contre les injections SQL.

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

TP4 — CRUD Java + MySQL

Objectifs du TP

Créer la base de données école dans MySQL via NetBeans.

Connecter Java à MySQL avec JDBC.

Réaliser les opérations INSERT, SELECT, UPDATE, DELETE.

Préparation — Créer la base de données

Dans l'onglet Services de NetBeans, connectez-vous à MySQL et exécutez ce script SQL :
CREATE DATABASE IF NOT EXISTS ecole;
USE ecole;

CREATE TABLE etudiants (

id INT AUTO_INCREMENT PRIMARY KEY,
nom VARCHAR(50) NOT NULL,
prenom VARCHAR(50) NOT NULL,
age INT,
moyenne DOUBLE DEFAULT 0.0
);

Exercice 1 — Insertion et affichage

Créez la classe ConnexionMySQL avec les paramètres de connexion à votre base

ecole.

Créez une méthode static void ajouterEtudiant(String nom, String prenom, int age).

Créez une méthode static void afficherTousLesEtudiants().

Dans le main, ajoutez 3 étudiants puis affichez-les tous.

Corrigé
import [Link].*;
public class GestionEtudiants {
static Connection getConn() throws SQLException {
return [Link](
"jdbc:mysql://localhost:3306/ecole","root","password");
}
public static void ajouterEtudiant(String nom,String prenom,int age){
String sql="INSERT INTO etudiants(nom,prenom,age) VALUES(?,?,?)";
try(Connection c=getConn();PreparedStatement ps=[Link](sql))
{
[Link](1,nom);[Link](2,prenom);[Link](3,age);

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

[Link]();
[Link]("Etudiant ajouté : "+prenom+" "+nom);
}catch(SQLException e){[Link]([Link]());}
}
public static void afficherTousLesEtudiants(){
try(Connection c=getConn();PreparedStatement
ps=[Link]("SELECT * FROM etudiants");
ResultSet rs=[Link]()){
while([Link]())
[Link]([Link]("id")+" | "+[Link]("prenom")
+" "+[Link]("nom"));
}catch(SQLException e){[Link]([Link]());}
}
public static void main(String[] args){
ajouterEtudiant("Mensah","Koffi",21);
ajouterEtudiant("Agbovi","Ama",20);
ajouterEtudiant("Dossou","Edem",22);
afficherTousLesEtudiants();
}
}

Exercice 2 — Mise à jour et suppression

Ajoutez une méthode modifierMoyenne(int id, double moyenne) qui met à jour la
moyenne d'un étudiant.

Ajoutez une méthode supprimerEtudiant(int id) qui supprime un étudiant par son id.

Testez les deux méthodes dans le main et affichez la liste après chaque opération.

Corrigé
public static void modifierMoyenne(int id, double moyenne){
String sql="UPDATE etudiants SET moyenne=? WHERE id=?";
try(Connection c=getConn();PreparedStatement ps=[Link](sql)){
[Link](1,moyenne); [Link](2,id);
int n=[Link]();
[Link](n+" ligne(s) modifiée(s)");
}catch(SQLException e){[Link]([Link]());}
}
public static void supprimerEtudiant(int id){
String sql="DELETE FROM etudiants WHERE id=?";
try(Connection c=getConn();PreparedStatement ps=[Link](sql)){
[Link](1,id);
int n=[Link]();
[Link](n+" étudiant(s) supprimé(s)");
}catch(SQLException e){[Link]([Link]());}
}

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

CM5 — Architecture DAO (Data Access Object)

1. Pourquoi le pattern DAO ?
Dans une application bien structurée, on sépare les responsabilités en couches distinctes. Le
pattern DAO isole tout le code d'accès à la base de données dans des classes dédiées, rendant
l'application plus maintenable et testable.

Couche Rôle Classes

Présentation Interaction avec l'utilisateur Main, Menu

(menu, IHM)

Métier (Business) Logique applicative, Service, Manager

traitements

DAO Accès à la base de données EtudiantDAO, CoursDAO

uniquement

Modèle (Bean) Représentation des données Etudiant, Cours

2. Structure du pattern DAO

2.1 La classe modèle (Bean)
// [Link] — simple objet de données
public class Etudiant {
private int id;
private String nom, prenom;
private int age;
private double moyenne;

// Constructeur sans id (pour INSERT)

public Etudiant(String nom, String prenom, int age) {
[Link]=nom; [Link]=prenom; [Link]=age;
}
// Constructeur complet (pour SELECT)
public Etudiant(int id, String nom, String prenom, int age, double moyenne) {
[Link]=id; [Link]=nom; [Link]=prenom;
[Link]=age; [Link]=moyenne;
}
// Getters et setters ...
public int getId() { return id; }
public String getNom() { return nom; }
public String getPrenom() { return prenom; }
public int getAge() { return age; }
public double getMoyenne(){ return moyenne; }
public void setMoyenne(double m){ [Link]=m; }
}

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

2.2 L'interface DAO

import [Link];

public interface IEtudiantDAO {

void ajouter(Etudiant e);
Etudiant trouverParId(int id);
List<Etudiant> trouverTous();
void modifier(Etudiant e);
void supprimer(int id);
}

2.3 L'implémentation MySQL

import [Link].*;
import [Link];
import [Link];

public class EtudiantDAOImpl implements IEtudiantDAO {

@Override
public void ajouter(Etudiant e) {
String sql = "INSERT INTO etudiants(nom,prenom,age,moyenne) VALUES(?,?,?,?)";
try (Connection c = [Link]();
PreparedStatement ps = [Link](sql)) {
[Link](1, [Link]());
[Link](2, [Link]());
[Link](3, [Link]());
[Link](4, [Link]());
[Link]();
} catch (SQLException ex) { [Link](); }
}

@Override
public List<Etudiant> trouverTous() {
List<Etudiant> liste = new ArrayList<>();
String sql = "SELECT * FROM etudiants";
try (Connection c = [Link]();
PreparedStatement ps = [Link](sql);
ResultSet rs = [Link]()) {
while ([Link]()) {
[Link](new Etudiant(
[Link]("id"), [Link]("nom"),
[Link]("prenom"), [Link]("age"),
[Link]("moyenne")
));
}
} catch (SQLException ex) { [Link](); }
return liste;
}

@Override
public Etudiant trouverParId(int id) {
String sql = "SELECT * FROM etudiants WHERE id=?";

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

try (Connection c = [Link]();

PreparedStatement ps = [Link](sql)) {
[Link](1, id);
ResultSet rs = [Link]();
if ([Link]()) return new Etudiant(
[Link]("id"), [Link]("nom"),
[Link]("prenom"), [Link]("age"),
[Link]("moyenne"));
} catch (SQLException ex) { [Link](); }
return null;
}

@Override
public void modifier(Etudiant e) {
String sql = "UPDATE etudiants SET nom=?,prenom=?,age=?,moyenne=? WHERE id=?";
try (Connection c = [Link]();
PreparedStatement ps = [Link](sql)) {
[Link](1, [Link]()); [Link](2, [Link]());
[Link](3, [Link]()); [Link](4, [Link]());
[Link](5, [Link]());
[Link]();
} catch (SQLException ex) { [Link](); }
}

@Override
public void supprimer(int id) {
String sql = "DELETE FROM etudiants WHERE id=?";
try (Connection c = [Link]();
PreparedStatement ps = [Link](sql)) {
[Link](1, id);
[Link]();
} catch (SQLException ex) { [Link](); }
}
}

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

TP5 — Implémenter le pattern DAO

Objectifs du TP

Structurer un projet Java en couches (Modèle, DAO, Interface).

Implémenter l'interface IEtudiantDAO avec MySQL.

Tester toutes les opérations CRUD via une classe de test.

Structure du projet à créer dans NetBeans

ProjetEcole/
├── modele/
│ └── [Link]
├── dao/
│ ├── [Link]
│ └── [Link]
├── connexion/
│ └── [Link]
└── [Link]

Exercice 1 — Mise en place complète du DAO

Créez le projet ProjetEcole dans NetBeans avec les packages ci-dessus.

Implémentez toutes les classes selon le CM5.

Dans [Link], créez un menu console avec les options :

1. Ajouter un étudiant

2. Afficher tous les étudiants

3. Modifier la moyenne d'un étudiant

4. Supprimer un étudiant

5. Quitter

Corrigé
import [Link];
import [Link];
import [Link];

public class Main {

public static void main(String[] args) {
EtudiantDAOImpl dao = new EtudiantDAOImpl();

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

Scanner sc = new Scanner([Link]);

int choix = 0;
do {
[Link]("\n=== GESTION ETUDIANTS ===");
[Link]("1. Ajouter 2. Afficher 3. Modifier 4.
Supprimer 5. Quitter");
[Link]("Votre choix : ");
choix = [Link](); [Link]();
switch(choix) {
case 1:
[Link]("Nom : "); String nom = [Link]();
[Link]("Prénom : "); String prenom =
[Link]();
[Link]("Age : "); int age = [Link]();
[Link](new Etudiant(nom, prenom, age));
[Link]("Etudiant ajouté !"); break;
case 2:
for (Etudiant e : [Link]())
[Link]([Link]()+" | "+[Link]()+"
"+[Link]()+" | "+[Link]()); break;
case 3:
[Link]("ID étudiant : "); int id = [Link]();
[Link]("Nouvelle moyenne : "); double moy =
[Link]();
Etudiant e = [Link](id);
if (e!=null)
{[Link](moy);[Link](e);[Link]("Mis à jour !");}
else [Link]("Etudiant introuvable."); break;
case 4:
[Link]("ID à supprimer : "); int sid =
[Link]();
[Link](sid); [Link]("Supprimé !"); break;
}
} while(choix != 5);
[Link]("Au revoir !");
}
}

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

Projet Final — Système de Gestion d'une École

Consignes générales

Ce projet est à réaliser individuellement ou en binôme.

Il doit être rendu sous forme de projet NetBeans compressé (.zip).

Une démonstration orale de 10 minutes sera demandée.

Le code doit être commenté et structuré en packages.

1. Base de données MySQL à créer

CREATE DATABASE gestion_ecole;
USE gestion_ecole;

CREATE TABLE personnes (

id INT AUTO_INCREMENT PRIMARY KEY,
nom VARCHAR(50), prenom VARCHAR(50), age INT,
type ENUM('etudiant','professeur') NOT NULL
);

CREATE TABLE etudiants (

id INT PRIMARY KEY,
matricule VARCHAR(20) UNIQUE,
moyenne DOUBLE DEFAULT 0,
FOREIGN KEY (id) REFERENCES personnes(id)
);

CREATE TABLE professeurs (

id INT PRIMARY KEY,
specialite VARCHAR(50),
salaire DOUBLE,
FOREIGN KEY (id) REFERENCES personnes(id)
);

CREATE TABLE cours (

id INT AUTO_INCREMENT PRIMARY KEY,
code VARCHAR(10) UNIQUE,
intitule VARCHAR(100),
credits INT
);

CREATE TABLE inscriptions (

etudiant_id INT, cours_id INT,
PRIMARY KEY (etudiant_id, cours_id),
FOREIGN KEY (etudiant_id) REFERENCES etudiants(id),
FOREIGN KEY (cours_id) REFERENCES cours(id)
);

Page Page
Support de Cours Java — POO & MySQL | SIL 2ème Année

2. Architecture Java attendue

GestionEcole/
├── modele/
│ ├── [Link] (classe abstraite)
│ ├── [Link] (extends Personne)
│ ├── [Link] (extends Personne)
│ └── [Link]
├── dao/
│ ├── [Link]
│ ├── [Link]
│ ├── [Link]
│ └── [Link]
├── connexion/
│ └── [Link]
└── [Link] (menu console interactif)

3. Fonctionnalités requises
• Gestion des étudiants : ajouter, afficher, modifier moyenne, supprimer
• Gestion des cours : ajouter, afficher, supprimer
• Inscription d'un étudiant à un cours
• Afficher les cours d'un étudiant donné
• Afficher les étudiants inscrits à un cours donné
• Menu console avec navigation claire

4. Barème d'évaluation

Critère Points

Structure du projet (packages, nommage) 3 pts

Modèle POO (héritage, encapsulation, polymorphisme) 5 pts

Connexion et opérations JDBC 4 pts

Pattern DAO correctement implémenté 4 pts

Menu fonctionnel et gestion des exceptions 2 pts

Qualité du code et commentaires 2 pts

TOTAL 20 pts

Bon courage !
Ce cours vous donne toutes les bases pour développer des applications Java professionnelles.

Page Page