TRAVAUX PRATIQUES – PROGRAMMATION EVENEMENTIELLE

Création d'une Application CRUD en Java

avec MySQL et JDBC

─────────────────────────────────────────

Guide pédagogique par M. NDJE MAN

À l'usage des étudiants – Niveau débutant à intermédiaire
Durée estimée : 3 à 4 heures

1/34
Introduction

Ce travail pratique a pour objectif de vous guider, étape par étape, dans la conception et le
développement d'une application Java complète dotée d'une interface graphique et connectée à
une base de données MySQL. À l'issue de ce TP, vous serez capable de créer un formulaire de
gestion de contacts permettant d'ajouter et de rechercher des enregistrements dans une base de
données.

Objectifs pédagogiques

À la fin de ce TP, vous serez capable de :

• Créer un projet Java avec interface graphique (GUI) dans NetBeans.

• Concevoir un formulaire Swing à l'aide du GUI Builder de NetBeans.
• Établir une connexion entre une application Java et une base de données MySQL via
JDBC.
• Implémenter les opérations d'ajout et de recherche de données (CRUD partiel).
• Appliquer les principes de la programmation événementielle en Java.

Technologies utilisées

Technologie Rôle

NetBeans IDE Environnement de développement intégré (IDE) pour Java

Java Swing Bibliothèque graphique pour créer des interfaces utilisateur

(GUI)

MySQL Système de gestion de base de données relationnelle

(SGBDR)

JDBC API Java standard pour se connecter à une base de données

XAMPP / WAMP Serveur local qui fait tourner MySQL et phpMyAdmin

phpMyAdmin Interface web pour administrer la base de données MySQL

2/34
Pré-requis

Avant de commencer ce TP, assurez-vous que les logiciels suivants sont installés et
opérationnels sur votre poste de travail :

• NetBeans IDE (version 12 ou supérieure recommandée) ;

• Java Development Kit (JDK 8 ou supérieur) ;
• XAMPP ou WAMP (pour disposer d'un serveur MySQL local) ;
• Le fichier [Link] (pilote JDBC pour MySQL).

Conseil : Si vous ne disposez pas encore du connecteur MySQL, vous pouvez le

télécharger gratuitement sur le site officiel de MySQL :
[Link]

3/34
Étape 1 : Réalisation du formulaire graphique

Dans cette première étape, vous allez construire l'interface graphique de l'application, c'est-à-
dire la fenêtre que l'utilisateur verra à l'écran. Vous utiliserez le GUI Builder de NetBeans, un
outil visuel qui permet d'assembler des composants par simple glisser-déposer, sans écrire de
code d'interface manuellement.
1.1 – Création du projet NetBeans

La première chose à faire est de créer un nouveau projet Java dans NetBeans. Suivez les étapes
illustrées ci-dessous :

Étape 1. Ouvrez NetBeans. Dans la barre de menus, cliquez sur File > New Project. La boîte
de dialogue qui s'ouvre vous permet de définir le type de projet. Suivez les 4 étapes indiquées
dans la capture d'écran ci-dessous.

Figure 1 – Boîte de dialogue de création d'un nouveau projet dans NetBeans (4 étapes à suivre dans l'ordre)

Attention : Sélectionnez bien la catégorie "Java" et le type de projet "Java

Application" avant de cliquer sur "Next". Une mauvaise sélection ici entraînerait l'absence
du GUI Builder dans les étapes suivantes.

4/34
Étape 2. Dans l'écran suivant, nommez votre projet FormulaireContact. Pensez
également à décocher la case "Create Main Class", car la classe principale sera gérée
automatiquement par la JFrame. Cliquez ensuite sur Finish.

Figure 2 – Nommez le projet "FormulaireContact" et décochez "Create Main Class"

Note : Décocher "Create Main Class" évite de générer une classe Main inutile. La
classe JFrame que vous créerez dans les étapes suivantes jouera ce rôle.

1.2 – Ajout de la fenêtre principale (JFrame)

Votre projet est maintenant créé. Il est temps d'y ajouter une fenêtre graphique. En Java Swing,
une fenêtre principale est représentée par la classe

Une JFrame est la fenêtre principale d'une application Swing. Elle constitue le conteneur
racine dans lequel vous placerez tous les composants graphiques (boutons, champs de texte,
tableaux, etc.).

Étape 3. Dans le panneau "Projects" à gauche, faites un clic droit sur votre projet > New >
JFrame Form. Nommez cette JFrame FrmContact puis cliquez sur Finish.

5/34
 Figure 3 – Création de la JFrame : nommez-la "FrmContact"

Figure 4 – Confirmation de la création de la JFrame dans la structure du projet

6/34
1.3 – Présentation de l'environnement GUI Builder

Après avoir cliqué sur "Finish", NetBeans ouvre automatiquement le GUI Builder. C'est l'outil
visuel qui vous permet de concevoir votre interface en glissant-déposant des composants.
Prenez le temps de vous familiariser avec ses trois zones principales avant de commencer :

Figure 5 – Vue générale du GUI Builder avec ses trois zones de travail : la zone de conception, la palette et
les propriétés

a) Zone de conception (Design Canvas) : C'est l'espace central où vous assemblez votre
interface. Vous y voyez en temps réel le rendu de votre fenêtre. Vous pouvez y faire glisser des
composants depuis la palette.

b) Palette (Palette) : Panneau situé à droite contenant tous les composants Swing disponibles
: boutons (JButton), champs de texte (JTextField), panneaux (JPanel), listes déroulantes
(JComboBox), tableaux (JTable), etc.

c) Fenêtre des Propriétés (Properties) : Panneau en bas à droite permettant de configurer les
attributs du composant sélectionné : son texte affiché, sa police de caractères, sa couleur de
fond, son comportement à la fermeture, son nom de variable dans le code, etc.

1.4 – Ajout du premier panneau (titre du formulaire)

Les composants Swing s'organisent grâce à des conteneurs appelés

Un JPanel est un conteneur intermédiaire qui permet de regrouper et d'organiser des

composants à l'intérieur d'une JFrame. Il joue le rôle d'une "zone" dans votre interface.

7/34
Étape 4. Depuis la palette, repérez le composant Panel (JPanel) et faites-le glisser sur
votre formulaire vide. Étirez-le ensuite sur toute la largeur du formulaire, comme montré ci-
dessous.

Figure 6 – Glisser-déposer d'un JPanel sur la fenêtre de conception

Figure 7 – Le JPanel étiré sur toute la largeur du formulaire

Étape 5. Faites un clic droit sur le Panel > Properties pour accéder à ses propriétés.

8/34
 Figure 8 – Accès aux propriétés du JPanel par clic droit

Étape 6. Dans la fenêtre des propriétés, sélectionnez la propriété border, puis choisissez
Bevel Border. Cliquez sur OK pour valider. Ce type de bordure donne un effet de relief au
panneau.

9/34
 Figure 9 – Sélection du type de bordure "Bevel Border" pour le premier JPanel

Étape 7. Depuis la palette, faites glisser un JLabel à l'intérieur du Panel. Double-cliquez

dessus pour le renommer en Informations du contact, puis déplacez-le légèrement vers la
droite pour améliorer la lisibilité.

Figure 10 – Le JLabel "Informations du contact" déposé dans le premier Panel

10/34
Étape 8. Faites un clic droit sur le JLabel > Properties pour modifier sa police.

Figure 11 – Accès aux propriétés du JLabel par clic droit

Étape 9. Dans la fenêtre des propriétés, cliquez sur la propriété font (1), puis configurez-
la en Bold (2), taille 24 pts. Cliquez sur OK (3) puis sur Close.

Figure 12 – Configuration de la police du JLabel : Bold, taille 24

11/34
1.5 – Ajout du second panneau (zone de saisie)

Étape 10. Faites glisser un second JPanel (1) en dessous du premier. Accédez à sa
propriété border (2) et choisissez cette fois Etched Border (3). Cliquez sur OK (4) puis
sur Close (5). Ce second panel accueillera tous les champs de saisie.

Figure 13 – Ajout du second JPanel avec la bordure "Etched Border"

Note : Le type "Etched Border" crée une fine bordure gravée qui délimite visuellement
la zone de saisie. C'est une convention courante dans les applications de bureau Java.

1.6 – Ajout des champs de saisie (Nom, Prénom, Téléphone)

À l'intérieur du second Panel, vous allez ajouter les composants permettant à l'utilisateur de
saisir ses informations. Pour chaque champ, vous aurez besoin d'un couple JLabel + JTextField.

JLabel : composant qui affiche un texte non modifiable (étiquette). Il sert à indiquer ce que
l'utilisateur doit saisir dans le champ voisin.

JTextField : composant permettant à l'utilisateur de saisir du texte sur une seule ligne.

 Étape 11. Pour le champ "Nom", placez un JLabel dans le second Panel, changez
son texte en "Nom" et configurez sa police en Bold, 14 pts. À côté, ajoutez un
JTextField : videz sa propriété text (pour qu'il soit vide au démarrage) et mettez
sa police en Bold, 14 pts.

12/34
  Étape 12. Renommez le JTextField en cliquant dessus avec le bouton droit > Change
Variable Name, puis saisissez le nom txtNom. Ce nom sera utilisé dans le code Java
pour récupérer la valeur saisie.

Figure 14 – Renommage du JTextField via "Change Variable Name"

Figure 15 – Confirmation du nouveau nom de variable "txtNom"

Attention : Les noms de variables sont cruciaux : ils vous permettront d'accéder aux
composants depuis le code Java. Utilisez des noms explicites : txtNom, txtPrenom, txtTel.
Une erreur dans ces noms provoquera des bugs difficiles à corriger.

Étape 13. Reproduisez la même procédure pour les champs Prénom (variable : txtPrenom)
et Téléphone (variable : txtTel). À ce stade, votre formulaire devrait ressembler à la figure
suivante :

13/34
 Figure 16 – Le formulaire avec les champs Nom, Prénom et Téléphone ajoutés

1.7 – Ajout de la liste déroulante pour le Sexe (JComboBox)

Étape 14. En dessous du champ Téléphone, ajoutez un JLabel (1) avec le texte "Sexe" et
un JComboBox (2) à côté.

Figure 17 – Ajout du JLabel "Sexe" et du JComboBox

Étape 15. Sélectionnez le JComboBox (1) et modifiez sa propriété model (2). Dans le
champ de texte qui s'ouvre, saisissez les deux options séparées par une virgule : Masculin
, Féminin. Ces valeurs apparaîtront dans la liste déroulante au moment de l'exécution.

14/34
 Figure 18 – Configuration du modèle du JComboBox avec les valeurs "Masculin" et "Féminin"

Note : Un JComboBox est un composant Swing qui affiche une liste déroulante.
L'utilisateur peut sélectionner une valeur parmi celles définies dans son "modèle". Il est
intégré dans la JFrame via un JPanel, qui sert de conteneur intermédiaire pour structurer
l'interface graphique.

Nommez ce JComboBox cmbSexe via "Change Variable Name".

1.8 – Ajout des boutons d'action

Étape 16. Depuis la palette, faites glisser deux composants JButton en dessous du second
JPanel (en dehors des panels, directement dans la JFrame). Configurez-les comme indiqué ci-
dessous :

Figure 19 – Les deux boutons "Ajouter" et "Rechercher" positionnés dans le formulaire

Configurez chaque bouton avec les propriétés suivantes :

• JButton 1 – Propriété Text :

Propriété Text = "Ajouter" | Variable Name = BtnAjout | Font = Bold,
12 pts
15/34
 Propriété Text = "Rechercher" | Variable Name = BtnRecherch | Font
= Bold, 12 pts

Figure 20 – Propriétés d'un bouton (Text, Variable Name, Font)

1.9 – Ajout de la table de données (JTable)

Étape 17. Depuis la palette, faites glisser un composant Table (JTable) dans votre
formulaire, sous les boutons. Ce tableau permettra d'afficher la liste des contacts enregistrés
dans la base de données.

Figure 21 – Ajout du composant JTable dans le formulaire

Étape 18. Renommez la table en tbContact via "Change Variable Name".

16/34
 Figure 22 – Renommage de la JTable en "tbContact"

1.10 – Centrage automatique du formulaire à l'écran

Étape 19. Cliquez sur la zone vide du formulaire (en dehors de tout composant) pour le
sélectionner. Faites un clic droit dessus pour accéder à ses propriétés.

Figure 23 – Accès aux propriétés du formulaire JFrame par clic droit

Étape 20. Dans la fenêtre qui s'ouvre, allez sur l'onglet Code (1), sélectionnez Generate
Center (2) puis cliquez sur Close. Cette option génère le code qui centrera automatiquement
votre fenêtre au milieu de l'écran à chaque lancement.

17/34
 Figure 24 – Sélection de "Generate Center" pour centrer le formulaire à l'écran

1.11 – Changement du thème visuel (Look & Feel)

NetBeans applique par défaut le thème visuel "Nimbus" à vos applications Swing. Bien que
moderne, ce thème peut parfois poser des problèmes de rendu. Vous allez le remplacer par le
thème "Metal", plus classique mais parfaitement stable.

Étape 21. Sélectionnez le formulaire FrmContact (1) et cliquez sur l'onglet Source (2)
pour afficher le code Java généré automatiquement.

18/34
Figure 25 – Passage à l'onglet "Source" pour accéder au code Java du formulaire

19/34
 Figure 26 – Vue du code généré automatiquement par NetBeans (code "behind" du formulaire)

Étape 22. Utilisez la fonction de recherche (raccourci Ctrl + F), tapez le mot Nimbus et
appuyez sur Entrée pour le localiser dans le code.

Figure 27 – Résultat de la recherche du mot "Nimbus" dans le code source

Étape 23. Une fois "Nimbus" localisé, remplacez-le par Metal dans la ligne de code
correspondante.

Figure 28 – Ligne de code contenant "Nimbus" avant modification

Figure 29 – La même ligne de code après remplacement de "Nimbus" par "Metal"

Conseil : Si vous avez du mal à trouver "Nimbus", vérifiez que vous êtes bien dans la
méthode main() du code source. Cette instruction se trouve généralement dans le bloc try
{} qui configure le Look & Feel de l'application.

1.12 – Configuration des colonnes de la table de données

Étape 24. Revenez sur l'onglet Design. Faites un clic droit sur la JTable tbContact, puis
sélectionnez Table Contents pour configurer ses colonnes.

20/34
 Figure 30 – Accès à la configuration "Table Contents" par clic droit sur la JTable

Étape 25. Dans l'onglet Rows, pour chacun des titres (Title1 à Title4), décochez les options
Delete, MoveUp et MoveDown. À chaque décochage, le compteur se décrémente. Continuez
jusqu'à atteindre zéro.

Figure 31 – Onglet "Rows" : désélection des options Delete, MoveUp et MoveDown

21/34
 Figure 32 – Le compteur se décrémente à chaque désélection, jusqu'à atteindre zéro

Étape 26. Passez ensuite sur l'onglet Columns et modifiez les titres des colonnes pour les faire
correspondre à vos champs : Nom, Prénom, Téléphone, Sexe. Cliquez sur Close pour
valider.

Figure 33 – Onglet "Columns" : renommage des colonnes selon les champs du formulaire

Résultat attendu : après toutes ces étapes, votre formulaire devrait ressembler à la figure ci-
dessous. Si ce n'est pas le cas, vérifiez que vous n'avez pas manqué une étape.

22/34
 Figure 34 – Aperçu du formulaire complet après configuration de toutes ses zones

Étape 2 : Code et connexion à la base de données MySQL

Dans cette seconde étape, vous allez relier votre interface graphique à une base de données
MySQL réelle. Vous apprendrez à créer la base de données, à intégrer le pilote JDBC
nécessaire, puis à écrire le code Java permettant de lire et d'insérer des données.

2.1 – Démarrage du serveur MySQL (XAMPP ou WAMP)

Étape 1. Avant de travailler avec MySQL, vous devez démarrer le serveur de base de données.
Ouvrez XAMPP ou WAMP (1) et démarrez le module MySQL. Accédez ensuite à
phpMyAdmin (2) via votre navigateur à l'adresse [Link]

Figure 35 – Panneau de contrôle XAMPP/WAMP avec MySQL démarré et accès à phpMyAdmin

23/34
 Attention : Le module MySQL doit impérativement être démarré (voyant vert) avant
de lancer votre application Java. Si MySQL n'est pas en cours d'exécution, votre
programme retournera une erreur de connexion au démarrage.

2.2 – Création de la base de données et de la table

Étape 2. Dans phpMyAdmin, créez une nouvelle base de données nommée contactdb. À
l'intérieur, créez une table nommée contacts avec les colonnes suivantes : nom, prenom,
tel, sexe (toutes de type VARCHAR).

Figure 36 – Création de la base de données "contactdb" et de la table "contacts" dans phpMyAdmin

Conseil : Pour créer la base de données, cliquez sur "New" dans le panneau gauche de
phpMyAdmin, entrez "contactdb" et validez. Pour la table, cliquez sur la base de données,
puis sur "Create table". Nommez la table "contacts" et définissez 4 colonnes. Choisissez le
type VARCHAR(100) pour toutes les colonnes.

2.3 – Ajout du pilote JDBC ([Link])

Java ne peut pas communiquer directement avec MySQL. Il a besoin d'un "traducteur", appelé

Le pilote JDBC (driver) est une bibliothèque Java (fichier .jar) qui sert d'intermédiaire entre
votre code Java et le serveur MySQL. Sans lui, toute tentative de connexion échouera, même
si MySQL est bien démarré.

24/34
 Figure 37 – Icône du fichier [Link] (pilote JDBC officiel de MySQL)

Étape 3. Pour intégrer ce pilote dans votre projet, procédez comme suit :

• LibrariesDans le panneau "Projects", repérez le dossier

• Add JAR/FolderFaites un clic droit sur ce dossier et sélectionnez

Figure 38 – Clic droit sur "Libraries" > "Add JAR/Folder" pour ajouter le pilote JDBC

• [Link] la boîte de dialogue, naviguez jusqu'à

l'emplacement du fichier
• Open (2)Sélectionnez le fichier (1) et cliquez sur

Figure 39 – Sélection du fichier [Link] dans l'explorateur de fichiers

25/34
 Figure 40 – Le pilote JDBC apparaît maintenant dans le dossier "Libraries" du projet

Note : Le fichier [Link] se trouve généralement dans le dossier

"bin" de votre installation XAMPP/WAMP, ou vous l'avez téléchargé séparément. Son
nom contient un numéro de version (ex: [Link]).

2.4 – Implémentation de la connexion JDBC dans le code Java

Étape 4. Revenez dans NetBeans, sélectionnez FrmContact et cliquez sur l'onglet Source
pour accéder au code de votre formulaire.

Figure 41 – Sélection de FrmContact dans le panneau de navigation

Figure 42 – Clic sur l'onglet "Source" pour afficher le code Java

Étape 5. En haut du fichier Java, juste avant la déclaration de la classe, ajoutez l'instruction
d'import suivante. Cette ligne importe d'un seul coup toutes les classes nécessaires pour
travailler avec une base de données en Java (connexion, requêtes, résultats, erreurs SQL) :

import [Link].*;

26/34
 Figure 43 – Ajout de l'import [Link].* en haut du fichier Java, avant la déclaration de classe

Étape 6. À l'intérieur de la classe FrmContact, juste avant le constructeur, déclarez les

quatre objets JDBC indispensables. Ce sont des variables globales de la classe :

// ─── Déclaration des objets JDBC ───────────────────────────────────

Connection con; // Représente la connexion active à la base de
données
PreparedStatement pst; // Permet de construire et exécuter des requêtes SQL
ResultSet rs; // Contient les résultats retournés par une requête
SELECT
DefaultTableModel dt; // Modèle de données pour afficher les résultats dans
la JTable

Étape 7. Toujours dans la classe, ajoutez la méthode connect() qui établit la connexion
avec MySQL. Voici le code à saisir :

public void connect() {

try {
// 1. Chargement du pilote JDBC
// Cette ligne informe Java du "traducteur" à utiliser pour MySQL
[Link]("[Link]");

// 2. Établissement de la connexion
// Format : "jdbc:mysql://[hôte]/[base_de_données]", "utilisateur",
"mot_de_passe"
// Ici : hôte = localhost, base = contactdb, user = root, mdp = vide
(XAMPP)
con = [Link]("jdbc:mysql://localhost/contactdb",
"root", "");

} catch (ClassNotFoundException ex) {

[Link]([Link]()).log([Link], null,
ex);
} catch (SQLException ex) {
[Link]([Link]()).log([Link], null,
ex);
}
}

27/34
 Note : Si votre serveur MySQL utilise un mot de passe pour l'utilisateur "root",
remplacez le dernier paramètre (la chaîne vide "") par votre mot de passe. Sur une
installation XAMPP standard, root n'a pas de mot de passe.

Étape 8. NetBeans signale deux erreurs dans votre code (soulignées en rouge). Ne vous
inquiétez pas, elles sont normales et attendues. Voici comment les corriger :

Correction 8a : Cliquez sur la ligne [Link](...). Une ampoule jaune

apparaît à gauche. Cliquez dessus et choisissez "Surround Statement with try-
catch".

Figure 44 – Suggestion de NetBeans : "Surround Statement with try-catch" pour [Link]()

Correction 8b : Cliquez sur la ligne [Link](...).

De même, cliquez sur l'ampoule et choisissez "Add catch Clause".

Figure 45 – Suggestion de NetBeans : "Add catch Clause" pour [Link]()

Conseil : Les erreurs signalées par NetBeans correspondent à des exceptions que Java
vous oblige à gérer explicitement. En utilisant les suggestions automatiques de l'IDE, vous
faites en sorte que les erreurs éventuelles (serveur MySQL absent, mauvais identifiants)
soient capturées proprement sans faire planter l'application.

Étape 9. Ajoutez l'appel connect() dans le constructeur de la classe FrmContact. Cela

garantit que la connexion est établie dès le lancement de l'application, avant toute interaction
avec l'utilisateur.

28/34
 Figure 46 – Ajout de l'appel connect() dans le constructeur de FrmContact

2.5 – Programmation événementielle et code complet

La programmation événementielle consiste à associer du code Java à des actions de l'utilisateur

(clic sur un bouton, frappe au clavier, etc.). Dans NetBeans, il suffit de double-cliquer sur un
composant pour générer automatiquement la méthode d'événement correspondante.

Étape 10. Retournez sur le Design et double-cliquez sur le bouton "Ajouter" puis sur le
bouton "Rechercher". NetBeans vous bascule automatiquement dans le code source et génère
les méthodes BtnAjoutActionPerformed et BtnRecherchActionPerformed.

Figure 47 – Double-clic sur les boutons pour générer les méthodes d'événement correspondantes

Voici l'ensemble du code à écrire ou à vérifier dans votre classe (en dehors des blocs
"Generated Code" automatiques) :

Code 1 – Déclarations des variables globales

À placer en haut de la classe, avant le constructeur :

29/34
 Connection con;
PreparedStatement pst;
ResultSet rs;
DefaultTableModel dt;

Code 2 – Appels dans le constructeur

Ces deux méthodes s'exécutent automatiquement au lancement de l'application :

connect(); // Établit la connexion à la base de données

contactTable(); // Charge et affiche tous les contacts dans la table

Code 3 – Méthode connect() (connexion à MySQL)

public void connect() {

try {
[Link]("[Link]");
con = [Link]("jdbc:mysql://localhost/contactdb",
"root", "");
} catch (ClassNotFoundException ex) {
[Link]([Link]()).log([Link], null,
ex);
} catch (SQLException ex) {
[Link]([Link]()).log([Link], null,
ex);
}
}

Code 4 – Méthode contactTable() (affichage des données)

Cette méthode interroge la base de données et remplit la JTable avec tous les contacts existants
:

public void contactTable() {

try {
// Préparation et exécution de la requête SELECT
pst = [Link]("SELECT * FROM contacts");
rs = [Link]();

// Récupération du modèle de la table et effacement des lignes

précédentes
dt = (DefaultTableModel) [Link]();

30/34
 [Link](0);

// Lecture ligne par ligne du résultat et ajout dans le tableau

while ([Link]()) {
[Link](new Object[]{
[Link]("nom"),
[Link]("prenom"),
[Link]("tel"),
[Link]("sexe")
});
}
} catch (SQLException ex) {
[Link]([Link]()).log([Link], null,
ex);
}
}

Code 5 – Action du bouton "Rechercher" (BtnRecherchActionPerformed)

Ce code est à placer à l'intérieur de la méthode générée par NetBeans pour le bouton Rechercher
:

try {
// Récupération du nom saisi dans le champ txtNom
String nomRecherche = [Link]();

// Préparation de la requête SQL paramétrée (le "?" sera remplacé par le

nom)
pst = [Link]("SELECT * FROM contacts WHERE nom = ?");
[Link](1, nomRecherche); // Affectation du paramètre
rs = [Link]();

if ([Link]()) {
// Un contact a été trouvé : affichage de ses données dans les champs
[Link]([Link]("prenom"));
[Link]([Link]("tel"));
[Link]([Link]("sexe"));
} else {
// Aucun contact trouvé : message d'information
[Link](this, "Aucun contact trouvé à ce nom.");
}

31/34
 } catch (SQLException ex) {
[Link]([Link]()).log([Link], null, ex);
}

Code 6 – Action du bouton "Ajouter" (BtnAjoutActionPerformed)

Ce code est à placer à l'intérieur de la méthode générée par NetBeans pour le bouton Ajouter :

try {
// Récupération des valeurs saisies dans les champs du formulaire
String nom = [Link]();
String prenom = [Link]();
String tel = [Link]();
String sexe = [Link]().toString();

// Préparation de la requête INSERT avec 4 paramètres

pst = [Link]("INSERT INTO contacts (nom, prenom, tel, sexe)
VALUES (?,?,?,?)");
[Link](1, nom);
[Link](2, prenom);
[Link](3, tel);
[Link](4, sexe);
[Link](); // Exécution de l'insertion

// Message de confirmation et réinitialisation des champs

[Link](this, "Contact ajouté avec succès !");
[Link]("");
[Link]("");
[Link]("");
[Link](); // Remet le curseur dans le champ Nom

contactTable(); // Rafraîchit le tableau pour afficher le nouveau contact

} catch (SQLException ex) {

[Link]([Link]()).log([Link], null, ex);
[Link](this, "Erreur lors de l'ajout : " +
[Link]());
}

2.6 – Résultat final

Une fois tout le code saisi correctement, exécutez votre application en appuyant sur la touche

32/34
Pour lancer l'application, appuyez sur F6 ou cliquez sur le bouton vert "Run Project" dans
NetBeans. Votre application doit s'afficher avec l'interface complète, les boutons fonctionnels
et la table prête à recevoir des données.

Figure 48 – Résultat final : l'application CRUD en cours d'exécution avec les contacts affichés dans la table

Note : Si l'application ne se lance pas, vérifiez : (1) que MySQL est bien démarré dans
XAMPP/WAMP, (2) que le fichier [Link] est bien dans les
"Libraries" du projet, (3) que l'import [Link].* est bien présent en haut du fichier Java, et
(4) que le nom de la base de données et de la table correspondent exactement à ceux utilisés
dans le code.

Récapitulatif et points clés à retenir

Ce TP vous a permis de mettre en pratique plusieurs notions fondamentales du développement
Java. Voici les points essentiels à bien mémoriser :

Concept Ce qu'il faut retenir

JFrame Fenêtre principale d'une application Swing. Elle est le

conteneur racine de toute l'interface.

33/34
JPanel Conteneur intermédiaire pour organiser les composants.
Permet de structurer l'interface en zones.

JTextField / Composants de saisie utilisateur. Leurs noms de variables

JComboBox servent à lire les données dans le code Java.

GUI Builder Outil visuel de NetBeans qui génère automatiquement le

code d'interface à partir du glisser-déposer.

JDBC API Java standard pour se connecter à une base de données.

Nécessite un fichier .jar spécifique au SGBD.

PreparedStatement Méthode sécurisée pour exécuter des requêtes SQL avec des
paramètres variables (évite les injections SQL).

ResultSet Objet qui contient les résultats d'une requête SELECT. On le

parcourt avec [Link]() et [Link]().

DefaultTableModel Modèle de données de la JTable. C'est via lui qu'on ajoute ou

supprime des lignes dynamiquement.

Programmation Paradigme où le code s'exécute en réponse aux actions de

événementielle l'utilisateur (clic, saisie, etc.).

34/34