Interfaces Graphiques - Interaction Avec Les Bases de Donnees PDF

Interfaces graphiques - Interaction avec les bases de données
Programmation Orientée Objet en JAVA

Module: M22 - 4ième Année FI-GTR
Pr. Abdessamad EL BOUSHAKI

abdessamad.elboushaki@gmail.com
ENSA de Fès
Université Sidi Mohammed Ben Abdellah
Pr. Abdessamad EL BOUSHAKI (ENSA de Fès) Programmation Orientée Objet avancée en JAVA 1
Interfaces graphiques Java

SWING et AWT
Définition
Une interface graphique ou GUI (Graphical User Interface) est:

I Une couche applicative destinée à fournir aux utilisateurs d’ordinateurs un
moyen attractif et facile pour interagir avec un programme.
I L’interface d’un programme qui profite des capacités graphiques d’un
ordinateur pour le rendre plus facile d’utilisation.
I Des interfaces graphiques bien conçues évitent à l’utilisateur d’avoir à
apprendre de complexes langages de commandes.
I Un ensemble d’écrans de présentations qui utilisent des éléments graphiques
(tels boutons et icônes) pour rendre un programme plus facile d’utilisation.
Une même application peut offrir différentes interfaces à l’utilisateur:
I Une interface graphique stricto sensu qui s’exécute sur son ordinateur.
I Une interface web qui s’exécute dans un navigateur Internet.
I Une interface WAP qui s’exécute sur un téléphone.
I Une interface terminal qui s’exécute sur des appareils spécifiques.
I Des services web qui offrent ses fonctionnalités à d’autres applications
SWING et AWT - Les éléments graphiques

Java offre trois types des éléments graphiques
I Les ”Components” (composants ou contenus)
I Les ”Containers” (conteneurs, qui sont eux-mêmes des composants)
I Les ”LayoutManagers” (Les gestionnaires de mise en forme)
Les ”Components”
I Constituent différents éléments de l’affichage (boutons, barres de menus, etc).
I Ce sont des sous-classes de la classe abstraite javax.swing.JComponent.
I Ex: JButton, JLabel, JTextArea, JCheckbox, etc.
Les ”Containers”
I Sont destinés à accueillir des composants (fenêtres, les applets, etc).
I des espace dans lesquels on peut positionner plusieurs composants.
I Gèrent l’affichage des composants.
I Ce sont des sous-classes de la classe java.awt.Container.
I La classe Container est elle-même une sous-classe de la classe Component.
I Ex: JFrame, JDialog, etc.
Les ”LayoutManagers”
I Gèrent la disposition des composants au sein d’un conteneur
Hiérarchie d’héritage des principaux éléments des interfaces graphiques en

Java (Containers)

Hiérarchie d’héritage des principaux éléments des interfaces graphiques en
Java (Components).

Exemple d’interface graphique SWING.
Les conteneurs graphiques - JFrame

La classe JFrame du paquetage javax.swing permet de créer des fenêtres
graphiques.
Composant du plus haut niveau
Contient les différents composants graphiques de l’application
Ne peut être intégré dans un autre conteneur
Peut contenir une barre de menu (JMenuBar)
Constructeurs: new JFrame(); ou bien new JFrame(String);
Méthodes utiles:
I setSize(int, int) ⇒ Fixe les dimensions de la fenêtre
I setTitle(String) ⇒ Définit le titre de la fenêtre
I setJMenuBar(JMenuBar) ⇒ Installe la barre de menu
I add(Component) ⇒ Intègre le composant indiqué
I setVisible(true) ⇒ Fait apparaı̂tre la fenêtre à l’écran
I setBackground(Color) ⇒ Modifier la couleur de fond d’un composant
I setForeground(Color) ⇒ Modifier la couleur du premier plan d’un
composant
I setBounds(int, int, int, int) ⇒ Modifier la position et la taille d’un
composant
Les conteneurs graphiques - JFrame

Exemple :
/** Importer toutes les classes des paquetages java . awt et javax . swing . * */
import javax . swing .*;
import java . awt .* ;
public class DisplayFrame {
public static void main ( String [] args ) {
JFrame f = new JFrame ( " My JFrame " ); // Cr é er un objet graphique
// ... components are added to its content frame .
f . setSize (300 ,200); // D é finir la taille
f . setVisible ( true ); // Afficher
}
}
Les conteneurs graphiques - JPanel
JPanel est un conteneur élémentaire destiné à contenir d’autres composants.

Un panneau est une sorte de ”sous-fenêtre”, sans titre ni bordure, qui doit
obligatoirement être associé par la méthode add (de la classe Container) à
un autre conteneur, généralement une JFrame.
Il est muni d’un gestionnaire de placement qui gère la stratégie de
placement des différents composants contenus dans le panneau.
Constructeurs: new JPanel(); ou bien new JPanel(LayoutManager);
Méthodes utiles:
I setLayout(LayoutManager) ⇒ Ajoute un gestionnaires de mise en forme
I add(Component) ⇒ Intègre le composant indiqué
I int getComponentCount() ⇒ Retourne le nombre de composants du
panneau.
I setBackground(Color) ⇒ Modifier la couleur de fond d’un composant
I void remove(Component) ⇒ Retire un composant
Les conteneurs graphiques - JPanel
Exemple :
import javax . swing .*;

public static void main ( String [] args ){
JFrame f = new JFrame ( " My JFrame " );
firstPanel = new JPanel ();
firstPanel . setPreferredSiz e (
new Dimension (250 , 400));
firstPanel . setBackground ( Color . BLUE );
secondPanel = new JPanel ();

secondPanel . setPreferredSiz e (
new Dimension (250 , 400));
secondPanel . setBackground ( Color . RED );
frame . setLayout ( new FlowLayout ());

frame . add ( firstPanel );
frame . add ( secondPanel );
frame . setVisible ( true );
}
}
Les composants graphiques - JTextArea

JTextArea: Une zone rectangulaire dans laquelle l’utilisateur peut entrer ou
modifier un texte
Contient une chaı̂ne de caractères
Constructeurs: new JTextArea(String texteAAfficher);
Méthodes utiles:
I setText(String) ⇒ Modifier le contenu
I String getText() ⇒ Renvoie le texte contenu dans le champ
Exemple:
Les composants graphiques - JTable

JTable: permet d’afficher des tables de données
Contient deux Arrays ([ ]): Les données (tableau multidimensionnel d’objets)
et Les intitulés des colonnes (vecteur de chaı̂nes de caractères)
Permet ou interdit la modification des données de la table
Constructeurs: new JTable(Object[ ][ ], String[ ]);
⇒ Il faut un tableau de chaı̂nes de caractères contenant les intitulés des
colonnes ⇒ Et une matrice d’objets dont chaque rangée est une ligne du
tableau
Méthodes utiles:
I int getRowCount() ⇒ le nombre de lignes
I int getColumnCount() ⇒ le nombre de colonnes
I Object getValueAt(int, int) ⇒ l’objet à l’intersection de ligne et colonne
I void setValueAt(Object, int, int) ⇒ Remplace la valeur à intersection
de ligne et colonne.
Exemple:
Les composants graphiques - JCheckBox

JCheckBox: permet à l’utilisateur d’effectuer un choix de type oui/non.
Contient un intitulé
Peut être sélectionnée ou non
Peut être activée ou désactivée (on peut ou non la cocher)
Constructeurs: new JCheckBox(String intitule);
Méthodes utiles:
I setText(String) ⇒ Modifier l’intitulé
I setEnabled(boolean) ⇒ Déterminer si la case est activée ou pas (peut être
cochée ou non)
I setSelected(boolean) ⇒ Déterminer si la case est cochée ou pas
I isEnabled() ⇒ Renvoie true si la case est activée et false si elle ne l’est pas.
I isSelected() ⇒ Renvoie true si la case est cochée et false si elle ne l’est pas.
Exemple:
Les composants graphiques - JLabel
JLabel: permet d’afficher dans un conteneur un texte (d’une seule ligne)

non modifiable, mais que le programme peut faire évoluer.
Constructeurs: new JLabel(String intitule);
Méthodes utiles:
Exemple:
Les composants graphiques - JButton

JButton: permet de déclencher une action lorsqu’il est activé à l’aide de la
souris.
Constructeurs: new JButton(String, Icon);
Méthodes utiles:
I addActionListener(Object) ⇒ Définir l’action
Exemple:
Les composants graphiques - JComboBox

JComboBox: permet d’associé un champs de texte et une boı̂te de liste à
sélection simple.
Contient une liste d’éléments sous forme de chaı̂nes de caractères
Contient un entier représentant le numéro de la ligne sélectionnée
Constructeurs: new JComboBox();
Méthodes utiles:
I addItem(String) ⇒ Ajouter un élément (chaı̂ne de caractères) dans la liste
I getSelectedIndex() ⇒ Renvoie le numéro de la ligne sélectionnée
Exemple:
Les composants graphiques - JRadioButton
JRadioButton: permet d’effectuer un choix de type oui/non. Mais sa

vocation est de faire partie d’un groupe de boutons dans lequel une seule
option peut être sélectionnée à la fois.
Constructeurs: new JRadioButton(String);
Méthodes utiles:
I isSelected() ⇒ permet de savoir si le bouton radio est sélectionné ou non
I setSelected(true) ⇒ faire le choix vrai
Exemple:
Les composants graphiques - JList

JList: permet de choisir une ou plusieurs valeurs dans une liste prédéfinie.
Initialement, aucune valeur n’est sélectionnée dans la liste.
Constructeurs: new JList(String []);
Méthodes utiles:
I setSelectedIndex(3) ⇒ sélection préalable de l’élément de rang 3
I setSelectionMode(Mode) ⇒ permet de modifier le type d’une boı̂te de liste
I getSelectedValue() ⇒ fournit la valeur sélectionnée. Son résultat est de
type Object.
Exemple:
Barres et éléments de menus - JMenuBar
JMenuBar: permet de créer une barre de menu (une seule par JFrame).
Contient différents menus (JMenu)
Constructeurs: new JMenuBar();
Méthodes utiles:
I add(JMenu) ⇒ Ajoute un menu dans la barre (de gauche à droite)
Exemple:
Barres et éléments de menus - JMenu

JMenu: permet de créer un menu dans une barre de menu.
Contient différents éléments (JMenuItem)
Constructeurs: new JMenu(String);
Méthodes utiles:
I add(JMenuItem) ⇒ Ajoute un élément dans le menu (de haut en bas)
I addSeparator() ⇒ Ajoute une ligne de séparation dans le menu
Exemple:
Barres et éléments de menus - JMenuItem

JMenuItem: permet de créer un élément de menu.
Cet item peut être muni d’un texte, d’une icône, d’un raccourci, et d’un
accélérateur.
Il peut être actif ou inactif.
Constructeurs: new JMenuItem(String);
Méthodes utiles:
I setText(String) ⇒ Modifie l’intitulé de l’élément du menu
I setIcon(ImageIcon) ⇒ affectation de l’icône
I setMnemonic(KeyEvent) ⇒ affectation du raccourci alt+m
I setEnabled(true) ⇒ l’item de menu est actif
Exemple:
Utiliser les composants et conteneurs prédéfinis

Exemple :
import javax . swing .* ;
class MaFenetre extends JFrame {
private JButton MonBouton ;
public MaFenetre (){
super () ; // appel du constructeur par d é faut de la classe JFrame
setTitle ( " Ma premi è re application " ) ;
setBounds (10 ,40 ,300 ,200) ;
MonBouton = new JButton ( " Salut le monde ! " ) ; /* cr é ation d ’ un bouton de
r é f é rence MonBouton portant l ’é tiquette Un bouton */
getC ontentPane (). add ( MonBouton ) ; /* Pour ajouter un bouton a une fen e ^ tre ,
il faut incorporer le bouton dans le contenu de la fen ^ e tre . La m é thode
getC ontentPane de la classe JFrame fournit une r é f é rence à ce contenu ,
de type Container . */
/* La m é thode add de la classe Container permet d ’ ajouter le bouton au
contenu de la fen e^ tre . */
}
}
public class MonProg {
public static void main ( String args []) {
JFrame fen = new MaFenetre () ;
fen . setVisible ( true ) ;
}
}
Utiliser les composants et conteneurs prédéfinis
Exemple :
Gestion des évènements
Un clic souris, la frappe d’une touche au clavier ou le changement de la taille

d’une fenêtre sont des exemples d’événements.
Les composants SWING en Java créent des événements. Ces événements
peuvent déclencher une action exécutée par d’autre(s) composant(s).
Java classe les événements en deux niveaux :
I les événements de bas niveau (par exemple, un clic dans une fenêtre)
I les événements de haut niveau (par exemple, une action sur un bouton qui
peut provenir d’un clic souris ou d’une frappe au clavier).
Un événement dépend du composant qui l’a généré. On appelle source d’un
événement l’objet qui l’a généré. Exemple:
I L’événement émis suite à un clic souris dans une fenêtre est de type
MouseEvent.
I L’événement émis suite à un clic souris sur un bouton est de type
ActionEvent.
Gestion des évènements - Mécanismes et structure
Une source d’événements

I Génère des objets événements
I Les fait écouter par un ensemble d’écouteurs d’événements
I En général: un composant ou conteneur graphique
Les objets événements
I Contiennent la description et les caractéristiques d’un événement
I Tout événement qui peut se produire dans une interface graphique est de type
XXXEvent, classe du paquetage java.awt.event ou du paquetage
javax.swing.event dérivée de la classe EventObject (classe du paquetage
java.util).
Les objets écouteurs
I xxxListener ou xxxAdapter
I Concrétisent des méthodes définies dans les Interfaces
I Indiquent leur réaction en réponse aux événements
I Sont des interfaces implémentables dans les classes
I Peuvent être implémentés par les sources d’événements elles-mêmes (Une
source d’événements peut s’écouter elle-même)
1 Un événement se produit
2 La source d’événement dans laquelle il se produit génère un objet de type
événement
3 La source transmet l’événement à son (ses) écouteur(s)
4 L’écouteur appelle la méthode correspondant au type d’événement et lui
passe en argument l’objet événement
5 La méthode en question spécifie les traitements à réaliser lorsqu’un
événement du type correspondant se produit
6 Dans ses traitements, la méthodes peut examiner les caractéristiques de
l’événement (position du curseur de la souris, code de la touche pressée au
clavier...) et adapter son comportement en fonction de ces caractéristiques
Evénements
I ActionEvent, AdjustmentEvent, ComponentEvent, ContainerEvent,
FocusEvent, ItemEvent, KeyEvent, MouseEvent, TextEvent, WindowEvent
Les Interfaces Ecouteurs

I ActionListener, AdjustmentListener, ComponentListener,
ContainerListener, FocusListener, ItemListener, KeyListener,
MouseListener, MouseMotionListener, WindowListener
Les Adapteurs correspondants

I ActionAdapter, WindowAdapter, KeyAdapter, MouseAdapter, etc.
Les Sources d’événements

I Button, List, MenuItem, TextField, ScrollBar, CheckBox, Component,
Container, Window
Gestion des évènements - Les méthodes des écouteurs

ActionListener (Action)
I actionPerformed (ActionEvent)
ItemListener (Item)
I itemStateChanged (ItemEvent)
MouseMotionListener (Mouse)
I mouseDragged (MouseEvent)
I mouseMoved (MouseEvent)
MouseListener (Mouse)
I mousePressed (MouseEvent)
I mouseReleased (MouseEvent)
I mouseEntered (MouseEvent)
I mouseExited (MouseEvent)
I mouseClicked (MouseEvent)
KeyListener (Key)
I keyPressed (KeyEvent)
I keyReleased (KeyEvent)
I keyTyped (KeyEvent)
FocusListener (Focus)
I focusGained (FocusEvent)
I focusLost (FocusEvent)
Gestion des évènements - Les méthodes des écouteurs

AdjustmentListener (Adjustment)
I adjustmentValueChanged (AdjustmentEvent)
ComponentListener (Component)
I componentMoved (ComponentEvent)
I componentHiddent (ComponentEvent)
I componentResize (ComponentEvent)
I componentShown (ComponentEvent)
WindowListener (Window)
I windowClosing (WindowEvent)
I windowOpened (WindowEvent)
I windowIconified (WindowEvent)
I windowDeiconified (WindowEvent)
I windowClosed (WindowEvent)
I windowActivated (WindowEvent)
I windowDeactivated (WindowEvent)
ContainerListener (Container)
I componentAdded (ContainerEvent)
I componentRemoved(ContainerEvent)
TextListener (Text)
I textValueChanged (TextEvent)
Gestion des évènements - Mise en œuvre
Un composant ne traite pas forcément lui même les événements qu’il génère.
Il délègue ce traitement à des écouteurs.
En fonction des événements qu’ils traitent, un écouteur doit implémenter une
interface particulière, dérivée de l’interface EventListener, qui correspond
à une catégorie d’événements.
Pour traiter un événement de type XXXEvent, un écouteur doit implémenter
l’interface XXXListener.
Usage
public class MaClasse implements XXXListener
Avantages:
I Meilleur sur le plan orienté objet
I La classe peut hériter d’une autre classe
I Consistance
Exemple : Interactions avec la souris
import java . awt . event .* ;

import javax . swing . event .* ;
class souris implements MouseListener
{
// M é thode appel é e lors du clic de souris
public void mouseClicked ( MouseEvent event )
{ System . out . println ( " clic dans la fenetre " ) }
// M é thode appel é e lors du survol de la souris
public void mouseEntered ( MouseEvent event ) { }
// M é thode appel é e lorsque la souris sort de la zone du bouton
public void mouseExited ( MouseEvent event ) { }
// M é thode appel é e lorsque l ’ on presse le bouton gauche de la souris
public void mousePressed ( MouseEvent event ) { }
// M é thode appel é e lorsque l ’ on rel ^
a che le clic de souris
public void mouseReleased ( MouseEvent event ) { }
}
Exemple : Sélection de menus et boutons

class GereBoutons implements Action Listene r
{
public void actionP er f or me d ( ActionEvent e )
{
// Que faire quand une action est d é clench é e ?
}
}
Exemple : Évènements de fenêtre

class Fenetre implements Windo wListen er
{
public void windowClosed ( WindowEvent e ) {}
public void windowI co n if ie d ( WindowEvent e ) {}
public void windowOpened ( WindowEvent e ) {}
public void windowClosing ( WindowEvent e ) { System . exit (0);}
public void w ind owD e i c o n i f i e d ( WindowEvent e ) {}
public void windowA ct i va te d ( WindowEvent e ) {}
public void w ind owD e a c t i v a t e d ( WindowEvent e ) {}
}
Gestion des évènements - Associer la source et l’écouteur
En implémentant ce qui précède dans la classe concernée, on rend alors la

classe en question capable de prendre en charge les événements du type
correspondant.
Il reste à associer chaque source potentielle d’événements (la fenêtre

principale, chaque élément de menu, chaque bouton, chaque liste déroulante
et chaque table) à son objet écouteur, instance de la classe correspondante.
Cela se fait en général pendant ou juste après la construction de l’objet

source au moyen d’une méthode addXXXListener(objetEcouteur);

Exemple : Évènements sur le bouton
import java . awt .* ; import java . awt . event .* ;

import javax . swing .* ; import javax . swing . event .* ;
public class Bouton extends JButton implements Act ionList ener {
{
public Bouton ( String str )
{
super ( str );
this . a ddA cti onL i s t e n e r ( this );
}
public void actionP er f or me d ( ActionEvent event )
{
System . out . println ( " clic sur le Bouton " );
}
}
public static void main ( String [] args ) {
JFrame f = new JFrame ( " Ma fen ^ e tre " );
Bouton b = new Bouton ( " Mon bouton " );
f . setSize (300 ,200);
f . getContentPane (). add ( b );
f . setVisible ( true );
}
}

Exemple : Évènements sur la fenêtre
import java . awt .* ; import java . awt . event .* ;

import javax . swing .* ; import javax . swing . event .* ;
class EcouteurSouris implements MouseListener {
// red é finition de la m é thode appel é e lors d ’ un clic souris
public void mouseClicked ( MouseEvent e ) {
int x = e . getX () ; int y = e . getY () ;
System . out . println ( " clic dans la fenetre au point de coordonnees
" + x + " , " + y ); }
// la red é finition des autres m é thodes est " vide "
public void mousePressed ( MouseEvent e ) { }
public void mouseReleased ( MouseEvent e ) { }
public void mouseEntered ( MouseEvent e ) { }
public void mouseExited ( MouseEvent e ) { }
}
class MaFenetre extends JFrame {
public MaFenetre (){
super ( " Une fenetre qui traite les clics souris " ) ;
setSize (300 , 200) ;
addMouseListene r ( new Ecou teurSou ris ());
}
}
public class MonProgEvt Cl i c1 {
JFrame fen = new MaFenetre () ; fen . setVisible ( true ) ;
}
}
Interaction avec les bases de

données
Bases de données
Une application informatique a le plus souvent (surtout en informatique

d’entreprise) besoin d’interagir avec une ou plusieurs bases de données
⇒ y a compris PostgreSQL, MySQL, SQL Server, Oracle, Access.
I Exemples : L’application qui permet à un agent bancaire d’effectuer des
opérations sur le compte de ses clients doit obtenir et enregistrer des données
sur la base de données de la banque
Or les bases de données sont en général centralisées et servent un grand

nombre de ”clients”.
Les bases de données se contentent donc en général de stocker l’information,

éventuellement de la valider, mais pas de la traiter.
Et elles se mettent à la disposition des applications pour leur fournir

l’information demandée ou pour stocker leurs modifications (en SQL).
La technologie ODBC
Dans le monde Windows, il existe une plateforme baptisée ODBC

⇒ODBC = Open DataBase Connectivity
Il s’agit d’une interface standard défini par Microsoft permettant de mettre
des bases de données à disposition des applications sous Windows.
Etant donné qu’il existe différents types de bases de données, et que chacune
d’entre-elles possède sa propre façon de traiter les requêtes SQL et de
renvoyer les résultats, ODBC permet d’obtenir des résultats identiques quel
que soit le type de base de données, sans avoir à modifier le programme
d’appel qui transmet la requête.
Chaque PC équipé de Windows possède une liste des DataSources ODBC
qui pointent chacune vers une base de données.
ODBC connaı̂t chaque type de base de données Windows et sait dans quel
langage lui parler.
Pour qu’un programme puisse accéder à une base de données, il suffit donc
que celle-ci soit déclarée dans la liste des DataSources ODBC.
La technologie JDBC
Le problème : Java n’est pas une plateforme Windows
I Java n’est donc pas lié en soi à ODBC
I En revanche, Les applications Java doivent pouvoir communiquer avec
n’importe quelle base de données
La technologie JDBC est un ensemble de classes prédéfinies permettant de
développer des applications capables de se connecter à des serveurs de bases
de données (SGBD).
A l’instar d’ODBC, JDBC peut dialoguer avec un grand nombre de bases de
données différentes (mais pas Access en tant que tel).
En particulier, JDBC comprend un pilote qui lui permet de dialoguer avec
ODBC.
La passerelle JDBC-ODBC
Pour accéder à une base de données ODBC, un programme Java doit donc
établir, avec JDBC, une connexion vers ODBC en précisant la DataSource
dont il a besoin.
On parle en général d’un Pont JDBC-ODBC.
La présentation des classes de l’API JDBC
Toutes les classes de JDBC sont dans le package java.sql. Il faut donc
l’importer dans tous les programmes devant utiliser JDBC.
import java . sql .*;
Il y a 4 classes importantes : DriverManager, Connection, Statement (et

PreparedStatement), et ResultSet, chacune correspondant à une étape
de l’accès aux données :
I DriverManager : Charger et configurer le driver de la base de données.
I Connection : Réaliser la connexion et l’authentification à la base de données.
I Statement (et PreparedStatement) : Contenir la requête SQL et la
transmettre à la base de données.
I ResultSet : Parcourir les informations retournées par la base de données
dans le cas d’une sélection de données.
Chacune de ces classes dépend de l’instanciation d’un objet de la précédente
classe.
Connexion à une base de données
La connexion à une base de données requiert au préalable le chargement du

pilote JDBC qui sera utilisé pour communiquer avec la base de données. Une
fabrique permet alors de créer une instance de type Connection qui va
encapsuler la connection à la base de données.
I Le chargement du pilote :
Class . forName ( " sun . jdbc . odbc . Jdbc OdbcDriv er " );
I L’établissement de la connexion:
String DBurl = " jdbc : odbc : testDB " ;

Connection con = DriverManager . getConnection ( DBurl );
Le code suivant décrit la création d’une connexion avec un user et un mot de

passe :
Connection con = DriverManager . getConnection ( BDurl , " myLogin " ,

" myPassword " );
Connexion à une base de données
programme d’essai :
import java . sql .*;

public class Essai {
public static final String jdbcdriver = " sun . jdbc . odbc . JdbcO dbcDriv er " ;
public static final String database = " jdbc : postgresql :// localhost / test " ;
private Connection conn ;
try
{
Class . forName ( jdbcdriver );
conn = DriverManager . getConnection ( database , " jumbo " ," 12345 " );
}
catch ( Exception e )
{
e . pr i ntStackTrace ();
}
}
}
L’exécution de requêtes SQL
Pour envoyer des requêtes à la BD une fois la connexion établie, il faut créer
un Statement:
Statement stmt = conn . cr ea t eS ta te m en t ();
Une fois le Statement créé, on peut alors lui envoyer les requêtes SQL sous la
forme de chaı̂nes de caractères :
String requete = " DELETE * FROM clients " ;
stmt . executeUpdate ( requete );
dans le cas de requêtes SELECT, il faut récupérer le résultat.
Les données issues de la requête sont rassemblées dans un jeu de résultats,

appelé ResultSet:
String requete = " SELECT * FROM client " ;

ResultSet rs = stmt . executeQuery ( requete );
L’exécution de requêtes SQL

On peut alors accéder aux enregistrements renvoyés un à un en demandant
chaque fois au ResultSet de nous renvoyer la ligne suivante:
while ( rs . next ())

{
int c_id = rs . getInt ( " client_id " );
String c_n = rs . getString ( " client_name " );
String c_fn = rs . getString ( " c l i e n t _ f i r s t n a m e " );
String c_ad = rs . getString ( " cli ent_addr ess " );
String c_ph = rs . getString ( " client_phone " );
int c_ab = rs . getInt ( " client_abonne " );
double c_c = rs . getDouble ( " client_credit " );
int c_am = rs . getInt ( " c l i e n t _ a n n e e m e m b r e " );
}
Notez que l’on récupère la valeur de chaque champ en utilisant la méthode

correspondant au type de données du champ (getInt, getFloat,
getString, getDate, etc.)
Il faut enfin toujours veiller à fermer les connexions:
rs . close ();
stmt . close ();
conn . close ();

Interfaces Graphiques - Interaction Avec Les Bases de Donnees PDF

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Interfaces Graphiques - Interaction Avec Les Bases de Donnees PDF

Загружено:

Авторское право:

Доступные форматы

Interfaces graphiques - Interaction avec les bases de données

Programmation Orientée Objet en JAVA

Pr. Abdessamad EL BOUSHAKI

Interfaces graphiques Java

Une interface graphique ou GUI (Graphical User Interface) est:

SWING et AWT - Les éléments graphiques

SWING et AWT - Les éléments graphiques

Hiérarchie d’héritage des principaux éléments des interfaces graphiques en

SWING et AWT - Les éléments graphiques

SWING et AWT - Les éléments graphiques

Les conteneurs graphiques - JFrame

Les conteneurs graphiques - JFrame

Les conteneurs graphiques - JPanel

JPanel est un conteneur élémentaire destiné à contenir d’autres composants.

Les conteneurs graphiques - JPanel

import javax . swing .*;

secondPanel = new JPanel ();

frame . setLayout ( new FlowLayout ());

Les composants graphiques - JTextArea

Les composants graphiques - JTable

Les composants graphiques - JCheckBox

Les composants graphiques - JLabel

JLabel: permet d’afficher dans un conteneur un texte (d’une seule ligne)

Les composants graphiques - JButton

Les composants graphiques - JComboBox

Les composants graphiques - JRadioButton

JRadioButton: permet d’effectuer un choix de type oui/non. Mais sa

Les composants graphiques - JList

Barres et éléments de menus - JMenuBar

Barres et éléments de menus - JMenu

Barres et éléments de menus - JMenuItem

Utiliser les composants et conteneurs prédéfinis

Utiliser les composants et conteneurs prédéfinis

Gestion des évènements

Un clic souris, la frappe d’une touche au clavier ou le changement de la taille

Gestion des évènements - Mécanismes et structure

Une source d’événements

Gestion des évènements - Mécanismes et structure

Gestion des évènements - Mécanismes et structure

Les Interfaces Ecouteurs

Les Adapteurs correspondants

Les Sources d’événements

Gestion des évènements - Les méthodes des écouteurs

Gestion des évènements - Les méthodes des écouteurs

Gestion des évènements - Mise en œuvre

Gestion des évènements - Mise en œuvre

Exemple : Interactions avec la souris

import java . awt . event .* ;

Gestion des évènements - Mise en œuvre

Exemple : Sélection de menus et boutons

import java . awt . event .* ;

Gestion des évènements - Mise en œuvre

Exemple : Évènements de fenêtre

import java . awt . event .* ;

Gestion des évènements - Associer la source et l’écouteur

En implémentant ce qui précède dans la classe concernée, on rend alors la

Il reste à associer chaque source potentielle d’événements (la fenêtre

Cela se fait en général pendant ou juste après la construction de l’objet

Gestion des évènements - Associer la source et l’écouteur

import java . awt .* ; import java . awt . event .* ;

Gestion des évènements - Associer la source et l’écouteur

import java . awt .* ; import java . awt . event .* ;

Interaction avec les bases de