🎓 Support de Cours Java, L2

Monsieur Diop, Serigne Mbacke

 1. Les Collections en Java - Les Listes

1.1 Introduction aux Collections

Les collections en Java sont des structures de données qui permettent de stocker et manipuler des groupes d'objets.
Elles font partie du framework Java Collections (package [Link]).

1.2 ArrayList

ArrayList est une liste dynamique basée sur un tableau redimensionnable. Elle permet un accès rapide aux éléments
par index.

Caractéristiques:

Accès rapide par index

Insertion/Suppression lente au milieu

Taille dynamique

Autorise les doublons

Maintient l'ordre d'insertion

Exemple d'utilisation:

import [Link];

public class ExempleArrayList {

public static void main(String[] args) {
// Création d'une ArrayList
ArrayList<String> etudiants = new ArrayList<>();

// Ajout d'éléments
[Link]("Amadou");
[Link]("Fatou");
[Link]("Moussa");
[Link]("Awa");

// Accès par index

[Link]("Premier étudiant: " + [Link](0));

// Modification
[Link](1, "Fatoumata");

// Taille de la liste
[Link]("Nombre d'étudiants: " + [Link]());
 // Parcours de la liste
for (String etudiant : etudiants) {
[Link]("Étudiant: " + etudiant);
}

// Suppression
[Link]("Moussa");
[Link](0); // Suppression par index

// Vérification
if ([Link]("Awa")) {
[Link]("Awa est dans la liste");
}
}
}

1.3 LinkedList

LinkedList est une liste doublement chaînée. Chaque élément pointe vers le suivant et le précédent.

Caractéristiques:

Insertion/Suppression rapide au début et à la fin

 Accès par index plus lent

Consomme plus de mémoire (pointeurs supplémentaires)

Idéale pour les files et piles

Exemple d'utilisation:

import [Link];

public class ExempleLinkedList {

public static void main(String[] args) {
LinkedList<Integer> nombres = new LinkedList<>();

// Ajout en fin
[Link](10);
[Link](20);
[Link](30);

// Ajout au début
[Link](5);

// Ajout à la fin
[Link](40);
 // Utilisation comme file (Queue)
[Link]("Premier élément: " + [Link]());
[Link]("Retirer premier: " + [Link]());

// Utilisation comme pile (Stack)

[Link](100); // Ajoute au début
[Link]("Sommet: " + [Link]());

// Parcours
for (Integer nombre : nombres) {
[Link](nombre);
}
}
}

💡 Conseil: Utilisez ArrayList pour un accès fréquent par index, et LinkedList pour des insertions/suppressions
fréquentes au début ou à la fin.

1.4 Set (Interface)

Set est une interface qui représente une collection ne contenant pas de doublons. Les principales implémentations
sont HashSet et TreeSet.
1.5 HashSet

HashSet utilise une table de hachage pour stocker les éléments. Il ne garantit pas l'ordre.

Caractéristiques:

Pas de doublons

Pas d'ordre garanti

Opérations rapides

Autorise un élément null

Exemple d'utilisation:

import [Link];

public class ExempleHashSet {

public static void main(String[] args) {
HashSet<String> villes = new HashSet<>();

// Ajout d'éléments
[Link]("Dakar");
[Link]("Saint-Louis");
[Link]("Thiès");
[Link]("Dakar"); // Ne sera pas ajouté (doublon)

[Link]("Taille: " + [Link]()); // Affiche 3

// Vérification
if ([Link]("Dakar")) {
[Link]("Dakar est dans le set");
}

// Parcours (ordre non garanti)

for (String ville : villes) {
[Link](ville);
}

// Suppression
[Link]("Thiès");

// Opérations ensemblistes
HashSet<String> autresVilles = new HashSet<>();
[Link]("Dakar");
[Link]("Ziguinchor");

// Union
HashSet<String> union = new HashSet<>(villes);
[Link](autresVilles);
 // Intersection
HashSet<String> intersection = new HashSet<>(villes);
[Link](autresVilles);
}
}

1.6 TreeSet

TreeSet utilise un arbre rouge-noir pour stocker les éléments dans un ordre trié.

Caractéristiques:

Pas de doublons

Éléments triés automatiquement

Opérations plus lentes que HashSet

N'autorise pas null

Exemple d'utilisation:
import [Link];

public class ExempleTreeSet {

public static void main(String[] args) {
TreeSet<Integer> notes = new TreeSet<>();

// Ajout d'éléments (seront triés automatiquement)

[Link](15);
[Link](12);
[Link](18);
[Link](10);
[Link](15); // Ne sera pas ajouté

// Parcours (ordre croissant)

for (Integer note : notes) {
[Link](note); // Affiche: 10, 12, 15, 18
}

// Méthodes spécifiques
[Link]("Plus petite note: " + [Link]());
[Link]("Plus grande note: " + [Link]());
[Link]("Note > 12: " + [Link](12));
[Link]("Note < 15: " + [Link](15));
 // Sous-ensembles
[Link]("Notes >= 12 et < 18: " + [Link](12, 18));
[Link]("Notes < 15: " + [Link](15));
[Link]("Notes >= 15: " + [Link](15));
}
}

1.7 Tableau Comparatif

Collection Ordre Doublons Performance Utilisation

ArrayList Maintenu Oui Accès rapide Accès fréquent par index

LinkedList Maintenu Oui Insert/Delete rapide Files, piles

HashSet Non garanti Non Très rapide Unicité des éléments

TreeSet Trié Non Moyenne Éléments triés uniques

 2. La Gestion des Exceptions

2.1 Introduction

Une exception est un événement qui perturbe le déroulement normal d'un programme. Java utilise un mécanisme
robuste pour gérer ces situations.

2.2 Hiérarchie des Exceptions

Throwable
├── Error (erreurs système graves)
└── Exception
├── RuntimeException (non vérifiées)
│ ├── NullPointerException
│ ├── ArrayIndexOutOfBoundsException
│ └── ArithmeticException
└── Exception vérifiées
├── IOException
├── SQLException
└── ClassNotFoundException
2.3 Try-Catch-Finally

public class ExempleExceptions {

public static void main(String[] args) {
// Exemple 1: Division par zéro
try {
int resultat = 10 / 0;
} catch (ArithmeticException e) {
[Link]("Erreur: Division par zéro!");
[Link]("Message: " + [Link]());
}

// Exemple 2: Accès à un tableau

try {
int[] tableau = {1, 2, 3};
[Link](tableau[5]);
} catch (ArrayIndexOutOfBoundsException e) {
[Link]("Index invalide!");
}

// Exemple 3: Multiple catch

try {
String texte = null;
[Link]([Link]());
 } catch (NullPointerException e) {
[Link]("Objet null!");
} catch (Exception e) {
[Link]("Autre erreur: " + e);
}

// Exemple 4: Finally (toujours exécuté)

try {
int[] nombres = {1, 2, 3};
[Link](nombres[1]);
} catch (Exception e) {
[Link]("Erreur: " + e);
} finally {
[Link]("Bloc finally toujours exécuté");
}
}
}

2.4 Créer ses Propres Exceptions

// Définition d'une exception personnalisée

class NoteInvalideException extends Exception {
public NoteInvalideException(String message) {
 super(message);
}
}

public class GestionNotes {

public static void verifierNote(int note) throws NoteInvalideException {
if (note < 0 || note > 20) {
throw new NoteInvalideException("La note doit être entre 0 et 20");
}
[Link]("Note valide: " + note);
}

public static void main(String[] args) {

try {
verifierNote(15); // OK
verifierNote(25); // Lance une exception
} catch (NoteInvalideException e) {
[Link]("Erreur: " + [Link]());
}
}
}

2.5 Try-with-Resources
Pour fermer automatiquement les ressources (fichiers, connexions, etc.):

import [Link].*;

public class TryWithResources {

public static void main(String[] args) {
// Les ressources sont fermées automatiquement
try (BufferedReader br = new BufferedReader(new FileReader("[Link]"))) {
String ligne = [Link]();
[Link](ligne);
} catch (IOException e) {
[Link]("Erreur de lecture: " + [Link]());
}
// Pas besoin de finally pour fermer br
}
}

⚠️ Important: Toujours gérer les exceptions de manière spécifique. Évitez d'utiliser catch(Exception e) sauf
nécessité absolue.
 3. Manipulation des Fichiers

3.1 Lecture de Fichiers

Méthode 1: BufferedReader

import [Link].*;

public class LectureFichier {

public static void main(String[] args) {
String nomFichier = "[Link]";

try (BufferedReader br = new BufferedReader(new FileReader(nomFichier))) {

String ligne;
while ((ligne = [Link]()) != null) {
[Link](ligne);
}
} catch (FileNotFoundException e) {
[Link]("Fichier non trouvé: " + nomFichier);
} catch (IOException e) {
[Link]("Erreur de lecture: " + [Link]());
 }
}
}

Méthode 2: Scanner

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

public class LectureAvecScanner {

public static void main(String[] args) {
try {
File fichier = new File("[Link]");
Scanner scanner = new Scanner(fichier);

while ([Link]()) {
String ligne = [Link]();
[Link](ligne);
}

[Link]();
} catch (FileNotFoundException e) {
[Link]("Fichier introuvable");
 }
}
}

3.2 Écriture dans les Fichiers

Méthode 1: BufferedWriter

import [Link].*;

public class EcritureFichier {

public static void main(String[] args) {
String nomFichier = "[Link]";

try (BufferedWriter bw = new BufferedWriter(new FileWriter(nomFichier))) {

[Link]("Première ligne");
[Link]();
[Link]("Deuxième ligne");
[Link]();
[Link]("Troisième ligne");

[Link]("Écriture réussie!");
 } catch (IOException e) {
[Link]("Erreur d'écriture: " + [Link]());
}
}
}

Méthode 2: PrintWriter

import [Link].*;

public class EcritureAvecPrintWriter {

public static void main(String[] args) {
try (PrintWriter pw = new PrintWriter(new FileWriter("[Link]", true))) {
// true pour ajouter à la fin (append)
[Link]("Amadou: 15");
[Link]("Fatou: 18");
[Link]("Moussa: %d%n", 16);

[Link]("Notes enregistrées!");
} catch (IOException e) {
[Link]();
}
 }
}

3.3 Opérations sur les Fichiers

import [Link];

public class OperationsFichiers {

public static void main(String[] args) {
File fichier = new File("[Link]");

// Vérifier l'existence
if ([Link]()) {
[Link]("Le fichier existe");

// Informations sur le fichier

[Link]("Nom: " + [Link]());
[Link]("Chemin: " + [Link]());
[Link]("Taille: " + [Link]() + " octets");
[Link]("Lecture: " + [Link]());
[Link]("Écriture: " + [Link]());
[Link]("Fichier: " + [Link]());
[Link]("Dossier: " + [Link]());
} else {
[Link]("Le fichier n'existe pas");
}

// Créer un fichier
try {
if ([Link]()) {
[Link]("Fichier créé");
}
} catch (IOException e) {
[Link]();
}

// Supprimer un fichier
if ([Link]()) {
[Link]("Fichier supprimé");
}

// Créer un dossier
File dossier = new File("mon_dossier");
if ([Link]()) {
[Link]("Dossier créé");
}

// Lister les fichiers d'un dossier

File repertoire = new File(".");
String[] fichiers = [Link]();
if (fichiers != null) {
for (String nom : fichiers) {
[Link](nom);
}
}
}
}
 4. Les Threads - Programmation Concurrente

4.1 Introduction aux Threads

Un thread (fil d'exécution) est une unité d'exécution indépendante au sein d'un programme. Les threads permettent
d'exécuter plusieurs tâches simultanément (multitâche).

📌 Pourquoi utiliser les threads ?

Améliorer les performances sur les processeurs multi-cœurs

Effectuer des tâches en arrière-plan (téléchargements, calculs)

Garder l'interface utilisateur réactive

Gérer plusieurs clients simultanément (serveurs)

4.2 Créer un Thread - Méthode 1: Hériter de Thread

public class MonThread extends Thread {

private String nom;
public MonThread(String nom) {
[Link] = nom;
}

@Override
public void run() {
// Code exécuté par le thread
for (int i = 1; i <= 5; i++) {
[Link](nom + " - Compteur: " + i);

try {
// Pause de 1 seconde
[Link](1000);
} catch (InterruptedException e) {
[Link](nom + " interrompu");
}
}
[Link](nom + " terminé!");
}

public static void main(String[] args) {

// Créer et démarrer les threads
MonThread thread1 = new MonThread("Thread-1");
MonThread thread2 = new MonThread("Thread-2");
 [Link](); // Démarre l'exécution
[Link]();

[Link]("Threads démarrés!");
}
}

4.3 Créer un Thread - Méthode 2: Implémenter Runnable (Recommandé)

Cette méthode est préférable car elle permet d'hériter d'une autre classe.

public class MonRunnable implements Runnable {

private String nom;

public MonRunnable(String nom) {

[Link] = nom;
}

@Override
public void run() {
for (int i = 1; i <= 5; i++) {
[Link](nom + " - Compteur: " + i);
try {
[Link](1000);
} catch (InterruptedException e) {
[Link]();
}
}
}

public static void main(String[] args) {

// Créer les Runnable
MonRunnable runnable1 = new MonRunnable("Runnable-1");
MonRunnable runnable2 = new MonRunnable("Runnable-2");

// Créer les threads avec les Runnable

Thread thread1 = new Thread(runnable1);
Thread thread2 = new Thread(runnable2);

// Démarrer
[Link]();
[Link]();
}
}
4.4 Créer un Thread - Méthode 3: Expression Lambda (Java 8+)

public class ThreadLambda {

public static void main(String[] args) {

// Avec expression lambda

Thread thread1 = new Thread(() -> {
for (int i = 1; i <= 5; i++) {
[Link]("Lambda Thread - " + i);
try {
[Link](500);
} catch (InterruptedException e) {
[Link]();
}
}
});

[Link]();

// Version encore plus courte

new Thread(() -> {
[Link]("Thread rapide exécuté!");
}).start();
 }
}

4.5 Cycle de Vie d'un Thread

// États d'un thread:

// 1. NEW - Thread créé mais pas démarré
Thread t = new Thread(runnable);

// 2. RUNNABLE - Thread en cours d'exécution

[Link]();

// 3. BLOCKED/WAITING - Thread en attente

// 4. TIMED_WAITING - Thread en attente avec timeout
[Link](1000);

// 5. TERMINATED - Thread terminé

4.6 Méthodes Importantes des Threads

public class MethodesThreads {
public static void main(String[] args) throws InterruptedException {

Thread thread = new Thread(() -> {

for (int i = 0; i < 10; i++) {
[Link]("Travail en cours... " + i);
try {
[Link](500);
} catch (InterruptedException e) {
[Link]("Thread interrompu!");
return; // Sortir si interrompu
}
}
});

[Link]();

// Obtenir le nom du thread

[Link]("Nom: " + [Link]());

// Définir un nom
[Link]("MonThreadPersonnalisé");

// Obtenir la priorité (1-10, défaut: 5)

 [Link]("Priorité: " + [Link]());

// Définir la priorité
[Link](Thread.MAX_PRIORITY); // 10

// Vérifier si le thread est vivant

[Link]("Est vivant: " + [Link]());

// Attendre que le thread se termine

[Link](); // Le thread principal attend

[Link]("Thread terminé");

// Obtenir le thread actuel

Thread threadActuel = [Link]();
[Link]("Thread principal: " + [Link]());
}
}

4.7 Synchronisation - Éviter les Problèmes de Concurrence

Quand plusieurs threads accèdent aux mêmes données, il faut synchroniser l'accès.
Problème sans synchronisation:

class Compteur {
private int compte = 0;

public void incrementer() {

compte++; // Opération non atomique!
}

public int getCompte() {

return compte;
}
}

public class ProblemeSynchronisation {

public static void main(String[] args) throws InterruptedException {
Compteur compteur = new Compteur();

// Créer 1000 threads qui incrémentent

Thread[] threads = new Thread[1000];
for (int i = 0; i < 1000; i++) {
threads[i] = new Thread(() -> {
for (int j = 0; j < 100; j++) {
[Link]();
 }
});
threads[i].start();
}

// Attendre tous les threads

for (Thread t : threads) {
[Link]();
}

// Résultat attendu: 100000, mais souvent inférieur!

[Link]("Compte final: " + [Link]());
}
}

Solution avec synchronized:

class CompteurSynchronise {
private int compte = 0;

// Méthode synchronisée
public synchronized void incrementer() {
compte++;
}

public synchronized int getCompte() {

return compte;
}
}

public class SolutionSynchronisation {

public static void main(String[] args) throws InterruptedException {
CompteurSynchronise compteur = new CompteurSynchronise();

Thread[] threads = new Thread[1000];

for (int i = 0; i < 1000; i++) {
threads[i] = new Thread(() -> {
for (int j = 0; j < 100; j++) {
[Link]();
}
});
threads[i].start();
}

for (Thread t : threads) {

[Link]();
}
 // Résultat garanti: 100000
[Link]("Compte final: " + [Link]());
}
}

Bloc synchronized:

class GestionRessource {
private int valeur = 0;

public void modifier() {

// Code non synchronisé
[Link]("Préparation...");

// Seul ce bloc est synchronisé

synchronized(this) {
valeur++;
[Link]("Valeur: " + valeur);
}

// Code non synchronisé

[Link]("Terminé");
 }
}

4.8 Exemple Pratique: Producteur-Consommateur

import [Link];
import [Link];

class Buffer {
private Queue<Integer> queue = new LinkedList<>();
private int capacite = 5;

public synchronized void produire(int valeur) throws InterruptedException {

// Attendre si le buffer est plein
while ([Link]() == capacite) {
[Link]("Buffer plein, producteur en attente...");
wait();
}

[Link](valeur);
[Link]("Produit: " + valeur + " | Taille: " + [Link]());

// Notifier les consommateurs

notifyAll();
}

public synchronized int consommer() throws InterruptedException {

// Attendre si le buffer est vide
while ([Link]()) {
[Link]("Buffer vide, consommateur en attente...");
wait();
}

int valeur = [Link]();

[Link]("Consommé: " + valeur + " | Taille: " + [Link]());

// Notifier les producteurs

notifyAll();
return valeur;
}
}

public class ProducteurConsommateur {

public static void main(String[] args) {
Buffer buffer = new Buffer();

// Thread producteur
Thread producteur = new Thread(() -> {
for (int i = 1; i <= 10; i++) {
try {
[Link](i);
[Link](500);
} catch (InterruptedException e) {
[Link]();
}
}
});

// Thread consommateur
Thread consommateur = new Thread(() -> {
for (int i = 1; i <= 10; i++) {
try {
[Link]();
[Link](1000);
} catch (InterruptedException e) {
[Link]();
}
}
});

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

4.9 ExecutorService - Gestion Avancée des Threads

ExecutorService facilite la gestion d'un pool de threads.

import [Link].*;

public class ExempleExecutor {

public static void main(String[] args) {

// Créer un pool de 3 threads

ExecutorService executor = [Link](3);

// Soumettre des tâches

for (int i = 1; i <= 10; i++) {
final int taskId = i;
[Link](() -> {
[Link]("Tâche " + taskId +
" exécutée par " + [Link]().getName());
try {
[Link](2000);
 } catch (InterruptedException e) {
[Link]();
}
});
}

// Arrêter l'executor (important!)

[Link]();

try {
// Attendre que toutes les tâches soient terminées
if () {
[Link]();
}
} catch (InterruptedException e) {
[Link]();
}

[Link]("Toutes les tâches sont terminées");

}
}

4.10 Callable et Future - Threads avec Valeur de Retour

import [Link].*;

public class ExempleCallable {

public static void main(String[] args) throws Exception {

ExecutorService executor = [Link]();

// Callable retourne une valeur

Callable<Integer> tache = () -> {
[Link]("Calcul en cours...");
[Link](3000);
return 42; // Résultat du calcul
};

// Soumettre la tâche et obtenir un Future

Future<Integer> future = [Link](tache);

[Link]("Tâche soumise, en attente du résultat...");

// Faire autre chose pendant le calcul

[Link]("Je peux faire autre chose ici!");

// Obtenir le résultat (bloque jusqu'à ce que disponible)

Integer resultat = [Link]();
 [Link]("Résultat: " + resultat);

[Link]();
}
}

⚠️ Points Importants sur les Threads:

Toujours utiliser start() et non run() pour démarrer un thread

Synchroniser l'accès aux ressources partagées

Fermer les ExecutorService avec shutdown()

Gérer les InterruptedException correctement

Éviter les deadlocks (verrouillages mortels)

 5. Connexion aux Bases de Données avec JDBC

5.1 Introduction à JDBC

JDBC (Java Database Connectivity) est une API Java permettant de se connecter et d'interagir avec des bases de
données relationnelles.

5.2 Étapes de Connexion

1. Charger le pilote JDBC

2. Établir la connexion

3. Créer un Statement

4. Exécuter des requêtes SQL

5. Traiter les résultats

6. Fermer les ressources

5.3 Exemple Complet avec MySQL

📌 Prérequis: Ajouter le driver MySQL ([Link]) au classpath du projet.

import [Link].*;

public class ExempleJDBC {

// Informations de connexion
private static final String URL = "jdbc:mysql://localhost:3306/ma_base";
private static final String USER = "root";
private static final String PASSWORD = "motdepasse";

public static void main(String[] args) {

Connection conn = null;
Statement stmt = null;
ResultSet rs = null;

try {
// 1. Charger le driver (optionnel depuis JDBC 4.0)
[Link]("[Link]");

// 2. Établir la connexion
conn = [Link](URL, USER, PASSWORD);
[Link]("Connexion réussie!");
// 3. Créer un Statement
stmt = [Link]();

// 4. Exécuter une requête SELECT

String sql = "SELECT * FROM etudiants";
rs = [Link](sql);

// 5. Traiter les résultats

while ([Link]()) {
int id = [Link]("id");
String nom = [Link]("nom");
String prenom = [Link]("prenom");
int age = [Link]("age");

[Link]("ID: " + id + ", Nom: " + nom +

" " + prenom + ", Age: " + age);
}

} catch (ClassNotFoundException e) {
[Link]("Driver non trouvé: " + [Link]());
} catch (SQLException e) {
[Link]("Erreur SQL: " + [Link]());
[Link]();
} finally {
// 6. Fermer les ressources (dans l'ordre inverse)
 try {
if (rs != null) [Link]();
if (stmt != null) [Link]();
if (conn != null) [Link]();
} catch (SQLException e) {
[Link]();
}
}
}
}

5.4 Insertion de Données

public class InsertionJDBC {

public static void main(String[] args) {
String url = "jdbc:mysql://localhost:3306/ma_base";
String user = "root";
String password = "motdepasse";

try (Connection conn = [Link](url, user, password);

Statement stmt = [Link]()) {

// Insertion simple
 String sql = "INSERT INTO etudiants (nom, prenom, age) " +
"VALUES ('Diop', 'Amadou', 22)";
int rowsAffected = [Link](sql);

[Link](rowsAffected + " ligne(s) insérée(s)");

} catch (SQLException e) {
[Link]("Erreur: " + [Link]());
}
}
}

5.5 PreparedStatement (Recommandé)

PreparedStatement est plus sûr et plus performant que Statement.

public class PreparedStatementExample {

public static void main(String[] args) {
String url = "jdbc:mysql://localhost:3306/ma_base";
String user = "root";
String password = "motdepasse";

// Requête avec paramètres

String sql = "INSERT INTO etudiants (nom, prenom, age) VALUES (?, ?, ?)";

try (Connection conn = [Link](url, user, password);

PreparedStatement pstmt = [Link](sql)) {

// Définir les paramètres (index commence à 1)

[Link](1, "Fall");
[Link](2, "Fatou");
[Link](3, 21);

// Exécuter
int rows = [Link]();
[Link](rows + " ligne(s) insérée(s)");

// Réutiliser le PreparedStatement
[Link](1, "Sow");
[Link](2, "Moussa");
[Link](3, 23);
[Link]();

} catch (SQLException e) {
[Link]();
}
 }
}

5.6 Mise à Jour et Suppression

public class UpdateDeleteJDBC {

public static void main(String[] args) {
String url = "jdbc:mysql://localhost:3306/ma_base";

try (Connection conn = [Link](url, "root", "motdepasse")) {

// UPDATE
String updateSQL = "UPDATE etudiants SET age = ? WHERE nom = ?";
try (PreparedStatement pstmt = [Link](updateSQL)) {
[Link](1, 24);
[Link](2, "Diop");
int rows = [Link]();
[Link](rows + " ligne(s) mise(s) à jour");
}

// DELETE
String deleteSQL = "DELETE FROM etudiants WHERE age < ?";
try (PreparedStatement pstmt = [Link](deleteSQL)) {
 [Link](1, 18);
int rows = [Link]();
[Link](rows + " ligne(s) supprimée(s)");
}

} catch (SQLException e) {
[Link]();
}
}
}

5.7 Gestion des Transactions

public class TransactionExample {

public static void main(String[] args) {
String url = "jdbc:mysql://localhost:3306/ma_base";

try (Connection conn = [Link](url, "root", "motdepasse")) {

// Désactiver l'auto-commit
[Link](false);

try (PreparedStatement pstmt1 = [Link](

"INSERT INTO etudiants (nom, prenom, age) VALUES (?, ?, ?)");
PreparedStatement pstmt2 = [Link](
"UPDATE etudiants SET age = age + 1 WHERE nom = ?")) {

// Première opération
[Link](1, "Ndiaye");
[Link](2, "Awa");
[Link](3, 20);
[Link]();

// Deuxième opération
[Link](1, "Diop");
[Link]();

// Valider la transaction
[Link]();
[Link]("Transaction réussie!");

} catch (SQLException e) {
// En cas d'erreur, annuler la transaction
[Link]();
[Link]("Transaction annulée: " + [Link]());
}

} catch (SQLException e) {
[Link]();
}
}
}
 6. Java Swing - Initiation aux Interfaces Graphiques

6.1 Introduction à Swing

Java Swing est une bibliothèque graphique pour créer des interfaces utilisateur (GUI). Elle fait partie de Java
Foundation Classes (JFC).

6.2 Première Fenêtre

import [Link].*;

public class PremierefenFenetre {

public static void main(String[] args) {
// Créer une fenêtre
JFrame fenetre = new JFrame("Ma Première Fenêtre");

// Définir la taille
[Link](400, 300);

// Positionner au centre de l'écran

[Link](null);
 // Définir l'action de fermeture
[Link](JFrame.EXIT_ON_CLOSE);

// Rendre visible
[Link](true);
}
}

6.3 Composants de Base

JLabel - Étiquette

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

public class ExempleLabel {

public static void main(String[] args) {
JFrame fenetre = new JFrame("Exemple Label");
[Link](400, 200);
[Link](JFrame.EXIT_ON_CLOSE);
[Link](new FlowLayout());
 // Créer un label
JLabel label = new JLabel("Bonjour Monsieur Diop!");
[Link](new Font("Arial", [Link], 16));
[Link]([Link]);

[Link](label);
[Link](true);
}
}

JButton - Bouton

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

public class ExempleBouton {

public static void main(String[] args) {
JFrame fenetre = new JFrame("Exemple Bouton");
[Link](300, 150);
[Link](JFrame.EXIT_ON_CLOSE);
[Link](new FlowLayout());
 JLabel label = new JLabel("Cliquez sur le bouton");
JButton bouton = new JButton("Cliquer ici");

// Ajouter un événement au bouton

[Link](new ActionListener() {
public void actionPerformed(ActionEvent e) {
[Link]("Bouton cliqué!");
[Link](fenetre, "Vous avez cliqué!");
}
});

[Link](label);
[Link](bouton);
[Link](true);
}
}

JTextField - Champ de texte

import [Link].*;
import [Link].*;
import [Link].*;
public class ExempleTextField {
public static void main(String[] args) {
JFrame fenetre = new JFrame("Formulaire");
[Link](350, 150);
[Link](JFrame.EXIT_ON_CLOSE);
[Link](new FlowLayout());

JLabel labelNom = new JLabel("Nom:");

JTextField champNom = new JTextField(15);
JButton boutonValider = new JButton("Valider");
JLabel resultat = new JLabel("");

[Link](new ActionListener() {
public void actionPerformed(ActionEvent e) {
String nom = [Link]();
[Link]("Bonjour " + nom + "!");
}
});

[Link](labelNom);
[Link](champNom);
[Link](boutonValider);
[Link](resultat);
[Link](true);
 }
}

6.4 Layouts (Gestionnaires de Disposition)

FlowLayout

// Les composants sont placés de gauche à droite

[Link](new FlowLayout());
[Link](bouton1);
[Link](bouton2);
[Link](bouton3);

BorderLayout

// 5 zones: NORTH, SOUTH, EAST, WEST, CENTER

[Link](new BorderLayout());
[Link](boutonHaut, [Link]);
[Link](boutonBas, [Link]);
[Link](boutonGauche, [Link]);
 [Link](boutonDroit, [Link]);
[Link](panneauCentral, [Link]);

GridLayout

// Grille de lignes et colonnes

[Link](new GridLayout(3, 2)); // 3 lignes, 2 colonnes
[Link](new JButton("1"));
[Link](new JButton("2"));
[Link](new JButton("3"));
[Link](new JButton("4"));
[Link](new JButton("5"));
[Link](new JButton("6"));

6.5 Application Complète

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

public class CalculatriceSimple extends JFrame {

private JTextField champNombre1;
private JTextField champNombre2;
private JLabel labelResultat;

public CalculatriceSimple() {
// Configuration de la fenêtre
setTitle("Calculatrice Simple");
setSize(350, 200);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLocationRelativeTo(null);
setLayout(new GridLayout(5, 2, 10, 10));

// Création des composants

JLabel label1 = new JLabel("Nombre 1:");
champNombre1 = new JTextField();

JLabel label2 = new JLabel("Nombre 2:");

champNombre2 = new JTextField();

JButton btnAddition = new JButton("Addition");

JButton btnSoustraction = new JButton("Soustraction");
JButton btnMultiplication = new JButton("Multiplication");
JButton btnDivision = new JButton("Division");

JLabel labelRes = new JLabel("Résultat:");

labelResultat = new JLabel("0");
[Link](new Font("Arial", [Link], 16));

// Ajout des événements

[Link](e -> calculer('+'));
[Link](e -> calculer('-'));
[Link](e -> calculer('*'));
[Link](e -> calculer('/'));

// Ajout des composants

add(label1);
add(champNombre1);
add(label2);
add(champNombre2);
add(btnAddition);
add(btnSoustraction);
add(btnMultiplication);
add(btnDivision);
add(labelRes);
add(labelResultat);

setVisible(true);
}

private void calculer(char operation) {

try {
double nb1 = [Link]([Link]());
double nb2 = [Link]([Link]());
double resultat = 0;

switch (operation) {
case '+':
resultat = nb1 + nb2;
break;
case '-':
resultat = nb1 - nb2;
break;
case '*':
resultat = nb1 * nb2;
break;
case '/':
if (nb2 != 0) {
resultat = nb1 / nb2;
} else {
[Link](this,
"Division par zéro impossible!");
return;
}
break;
}
 [Link]([Link](resultat));

} catch (NumberFormatException e) {
[Link](this,
"Veuillez entrer des nombres valides!");
}
}

public static void main(String[] args) {

new CalculatriceSimple();
}
}

6.6 Autres Composants Utiles

// JCheckBox - Case à cocher

JCheckBox caseJava = new JCheckBox("Java");
JCheckBox casePython = new JCheckBox("Python");

// JRadioButton - Bouton radio (sélection unique)

JRadioButton radioHomme = new JRadioButton("Homme");
JRadioButton radioFemme = new JRadioButton("Femme");
 ButtonGroup groupe = new ButtonGroup();
[Link](radioHomme);
[Link](radioFemme);

// JComboBox - Liste déroulante

String[] villes = {"Dakar", "Thiès", "Saint-Louis", "Ziguinchor"};
JComboBox<String> comboVilles = new JComboBox<>(villes);

// JTextArea - Zone de texte multiligne

JTextArea textArea = new JTextArea(5, 20);
JScrollPane scrollPane = new JScrollPane(textArea);

// JPasswordField - Champ mot de passe

JPasswordField champMotDePasse = new JPasswordField(15);

💡 Conseil: Pour créer des interfaces plus modernes, explorez JavaFX qui est la technologie GUI
recommandée pour les nouvelles applications Java.
 Conclusion
Ce support de cours couvre les bases essentielles du développement Java:

Collections: ArrayList, LinkedList, HashSet, TreeSet pour gérer des groupes de données

Exceptions: Gestion robuste des erreurs avec try-catch-finally

Fichiers: Lecture et écriture de fichiers avec différentes méthodes

Threads: Programmation concurrente et multitâche

JDBC: Connexion et manipulation de bases de données

Swing: Création d'interfaces graphiques utilisateur

📚 Pour aller plus loin:

Pratiquez régulièrement avec des exercices

Consultez la documentation officielle Java

Créez des projets personnels pour appliquer vos connaissances

Explorez les frameworks modernes (Spring, Hibernate, JavaFX)

Bon apprentissage, Monsieur Diop! 🎓