Module : JAVA

Objectifs : Java est l’une des technologies les plus répandues pour le développement des applications.
Notre formation java commence par une présentation du langage et des concepts objets puis la
conception et réalisation de fenêtre java enfin l’interfaçage d’une base de données à l’aide de la
technologie JAVA

Volume 20 heures

Chargé du cours : M Serge GNAGBO (47264047)

Outils : JDK, NetBeans, MySQL

Progression
CHAPITRE 1 : Notions du langage 3h

I- Présentation du langage
II- La structure d’un programme java
III- Les instructions élémentaires
a. Variables
b. Opérateurs
c. Instruction d’entrées/sortie
d. Les fonctions
e. Les tableaux

CHAPITRE 2 : Programmation orientée objet 6h

I- La classe
II- Les objets
III- L’héritage
IV- Le polymorphisme
V-

CHAPITRE 3 : les fenêtres 3h

CHAPITRE 4 : Accès aux bases de données 8 h

I- Implémentation de la base de données

II- Réalisation de la couche métier
III- Réalisation des interfaces utilisateurs

1
 Chapitre I : Notions du langage
I- Présentation de JAVA
a. Historique
Le langage Java est un langage de programmationinformatiqueorienté objet créé par James Gosling et Patrick
Naughton, employés de Sun Microsystems, avec le soutien de Bill Joy (cofondateur de Sun Microsystems en
1982), présenté officiellement le 23 mai 1995 au SunWorld.

La particularité principale de Java est que les logiciels écrits dans ce langage sont très facilement portables sur
plusieurs systèmes d’exploitation tels que UNIX, Windows, Mac OS ou GNU/Linux, avec peu ou pas de
modifications. C’est la plate-forme qui garantit la portabilité des applications développées en Java.

Le langage reprend en grande partie la syntaxe du langage C++, très utilisé par les informaticiens. Néanmoins,
Java a été épuré des concepts les plus subtils du C++ tels que les pointeurs et références, et l’héritage multiple
remplacé par l’implémentation des interfaces. Les concepteurs ont privilégié l’approche orientée objet de sorte
qu’en Java, tout est objet à l’exception des types primitifs (nombres entiers, nombres à virgule flottante, etc.)

b. Les éditions de JAVA

Les différentes éditions de JAVA sont :

- Java SE (standard edition) : J2SE (Java 2 Standard Edition) est l'une des éditions (ou
distribution) du framework 'Plate-forme Java' d'Oracle, destinée plus particulièrement aux applications
pour poste de [Link] plateforme contient outre toutes les API de base:
o toutes les API spécialisées dans le poste client (JFC et donc Swing, AWT et Java2D),
o ainsi que des API d'usage général comme JAXP (pour le parsingXML)
o et JDBC (pour la gestion des bases de données).

Il a été renommé Java SE par Sun Microsystems juste après son rachat par Oracle Corporation en
2009 pour 7 milliards de dollars.

- Java EE (enterpriseedition), s'appuyant sur Java SE :Java Enterprise Edition, ou Java EE

(anciennement J2EE), est une spécification pour la techniqueJava de Sun plus particulièrement
destinée aux applications d’entreprise. Ces applications sont considérées dans une approche multi-
niveaux. Dans ce but, toute implémentation de cette spécification contient un ensemble d’extensions
au framework Java standard (JSE, Java Standard Edition) afin de faciliter la création d’applications
réparties. On peut y implementer les applications comme :
o Servlet : Composant représentant le C du paradigme MVC
o Portlet : Conteneur Web (extension de l’API Servlet)
o JavaServer Pages (JSP) : Framework Web
o Java Standard Tag Library (JSTL) : bibliothèque de balises pour les JSP
o JavaServer Faces (JSF) : Java Server Face, Framework Web, extension des JSP
o EJB : Composants distribués transactionnels
o JNDI : API de connexion à des annuaires, notamment des annuaires LDAP, et espace
de noms d’objet (ENC)
o JDBC : API de connexion à des bases de données
o Java Message Service (JMS) : API de communication asynchrone par message
o JavaMail : API de gestion des mails
o JPA : API de gestion de la persistance des données
2
 o …
- Java ME (micro edition), indépendante des deux précédentes :Java 2 Micro Edition ou Java
ME (anciennement J2ME) est le frameworkJava spécialisé dans les applications mobiles. Il est né en
1999, de la volonté de Sun de structurer ses différentes plateformes, et notamment JavaCard,
PersonnalJava et EmbeddedJava sous l'appellation J2ME. Des plates-formes Java compatibles avec
J2ME sont embarquées dans de nombreux téléphones portables et PDA.

Une plate-forme J2ME est composée :

o d'une KVM (Kilobyte Virtual Machine), une machine virtuelle capable d'exécuter une
application Java
o d'une « configuration », une API donnant accès aux fonctions de base du système
o d'un « profil », une API donnant accès aux fonctions spécifiques de la plate-forme.

c. les outils de JAVA

- Le Java Development Kit (JDK) désigne un ensemble de bibliothèques logicielles de base du

langage de programmationJava, ainsi que l'environnement dans lequel le code Java est compilé pour
être transformé en bytecode afin que la machine virtuelle Java (JVM) puisse l'interpréter.
- L'environnement d'exécution Java (abr. JRE pour Java RuntimeEnvironment) est un logiciel
qui permet l'exécution des programmes écrits en langage de programmationJava1. Il est distribué
gratuitement par Oracle Corporation et fonctionne sur les systèmes d'exploitationWindows, Mac OS X
et Linux2. Il se compose d'une machine virtuelle, de bibliothèques logicielles utilisées par les
programmes Java et d'un plugin pour permettre l'exécution de ces programmes depuis les navigateurs
web1.

d. Les éditeurs de java

Pour éditer un programme java on peut utiliser :

 Editeur texte : éditeurs :EDIT ,Bloc-notes, ConTEXT, Crimson Editor, PSPad,

TextPad,Notepad2,Notepad++ ,UltraEdit, Nano, Vi,Vim,Emacs,…

 Environnement de developpement intégré :

3
 Les plus utilisés sont Eclipse, NetBeans

II- Structure d’un programme java

a. Syntaxe
L1- package <nom_package>;

L2- [import <classe dependante>;]

L3- public class <nomClasse> {

L4- public static void main(String[] args) {

L5- }

L6- }

b. Commentaire
1- On appelle package le dossier qui contient les fichiers, les fichiers du même package peuvent
se partager des données. Dans un programme java, on peut ajouter un package si on a
plusieurs fichiers à créer mais si on a un seul fichier on peut s’en passer.
2- A la ligne 2 on importe une classe si on doit utiiser une fonction qui existe dans cette classe par
defaut on a le JDK standard mais il faut ajouter certaines classes pour benéficier des fonctions
de ces classes.
3- A la ligne 3 tout programme java est une classe dont la classe public est celle qui donne son
nom au fichier. Cette classe peut avoir des arguments.
4- Tout bloc java est delimité par {…}
5- La fonction principale est main(), toute classe qui a la fonction main() peut être executée sinon
pas.
6- Java est sensible à la classe
4
 7- Les commentaires son // pour une ligne ou /* */ sur plusieurs lignes

c. Cycle de vie d’un programme java

editer compiler executer

Buy SmartDraw!- purchased copies print this
document without a watermark .
.java .class
Visit [Link] or call 1-800-768-3729.

compiler

.jar

III- Instructions élémentaires

a. Les variables
Algorithme Java
déclaration
<identifiant> :<type> <type><identifiant> ;
Les types
entier Int, long, short, unsigned int,
Reel Float, double
Caractère Char
Booléen Boolean
Chaine String (Classe)
Exemple
Declareri comme un entier, nombre comme un réel , lettre comme un caractère, mot comme une
chaîne

b. Les opérateurs
- Arithmétique :+,-,*,/,%(reste de la division entière)
- Affectation : =
- Comparaison : <, <=, >, >=, ==, !=
- Logique : || (ou), && (et), !(non)
- Concaténation : +

5
 c. Les instructions d’entrée et de sortie
i. Instruction de sortie
Syntaxe

[Link](<message>) ;

[Link](<message>) ; si on souhaite passer à la ligne après.

Exemple
Afficher "bonjour Reséau Telecom"

package exemple;
public class Exemple {

public static void main(String[] args) {

[Link]("Bonjour Reseau Telecom");
}
}
ii. Instruction d’entrée
Cette instruction se fait en fonction du type de la variable qu’on souhaite lire.
Syntaxe
//On definit un objet de Scanner qui definitles opération de
saisie en mode console
Scanner <objet>= new Scanner(<flux entrée>);
<identifiant>= <objet>.next<type>();
Exemple
nextInt() : retourne un entier
next() : une chaîne de caractère
nextDouble() : un réel
nextFloat() : un réel
nextBoolean() : un boolean
mais pour créer un objet de Scanner , il faut importer le package [Link]

exemple : ecrire un programme java qui affiche la somme de deux nombres entiers saisis.
package exemple;
//on ajoute la classe au programme
import [Link];
public class Exemple {
public static void main(String[] args) {
//on créer une instance de flux d'entrée sur la console
Scanner sc= new Scanner([Link]);
[Link]("Entrez le premier nombre");
//on saisit le premier nombre
int nbre1= [Link]();
[Link]("Entrez le second nombre");
int nbre2= [Link]();
// on effectue l'operation
int somme= nbre1+nbre2;
// on affiche le resultat
[Link]("la somme est "+somme);
//on affiche sous la forme 1+2=3
[Link](nbre1+" + "+ nbre2+" = "+ somme);

6
 }
}

IV- Les structures de contrôles

a. L’alternative conditionnelle
Algorithme Java
Si(<condition>) alors if (<condition>){
Action1 Action1
Sinon }else{
Action2 Action2
Fsi }

Exemple : ecrire un programme java qui affiche dans l’ordre croissant 2 entiers saisis

b. Le choix
Algorithme Java
Suivant <expression> faire switch(<expression>){
Cas <val1> : action1 case <val1> : action1 ;
Cas <val2> : action2 break ;
…. case <val2> : action2 ;
Sinon : action_defaut break ;
FinSuivant …
default : action_defaut ;
}
Exemple : ecrire un programme java qui affiche la facture d’un article dont on saisit la catégorie, le prix unitaire
et la quantité.Sachant que le client bénéficie d’une remise suivant la catégorie
7
Catégorie Taux de remise
1 et 3 5%
2 8%
4 et 5 2%

c. Les itérations
Algorithme Java
TantQue (<condition>) Faire while(<condition>){
Action Action
FTQ }
Repeter do{
Action Action
JQA(<condition>) }while(<conditon>
Pour <cp><-init à final [pas for(<initialisation> ;<test> ;<incr
<increment>] ementation>){
Action action
FPour }

8
Exemple : ecrire un programme java qui affiche le montant d’une facture dont on saisit pour une ligne le prix
unitaire et la quantité tant que l’operateur saisisse N ou n à la question "ajouter un nouvel article o ou n"

V- Les tableaux
a. Syntaxe
<type>[] <identifiant> = new <type>[<taille>] ;

Exemple

Declarer un tableau de 5 noms ;

String[] mesNom= new String[5] ;

Un element du tableau a la valeur à l’indice <identifiant>[<indice>]

Exemple : la valeur de mesNom à l’indice 2 est mesNom[2] sachant qu’on compte les indice à partir de 0.

b. Opération sur les tableaux

Initialisation des tableaux

- Initialiser avec des constantes

o Exemple : soit le tableau des jours qui contient les 7 jours de la semaines

String[] jour={"lundi", "mardi",

"mercredi","jeudi","vendredi","samedi","dimanche"};

9
 - Saisir successive des éléments du tableau
o Exemple : soit le tableau des recettes journalières qui est un
tableau de 7 éléments entiers
Recettes[0]=[Link]()

Exemple :WoroWoro

écrire un programme qui affiche la recette hebdomadaire, le jour où le chauffeur a le mieux travaillé.

VI- Procedures et fonctions

Algorithme Java
Fonction public static
<nomFonction>(<arg> :<type>,..) :<type> <type><nomF>(<type><arg>, …){
Variable return valeur;
[ <variable locale> :<type>] }
Debut
//operations
Retourner valeur
Fin

Procedure <nomProc>(<arg> :<type>,…) public static void

Variable <nomP>(<type><arg>, …){
[ <variable locale> :<type>] //action
Debut }
//operations

Fin

Exemple

Soit la procedureafficher() qui affiche un message passé en argument

10
public static void afficher(String message){

[Link](message);

Dans la fonction principale on appelle cette procedure en faisant

Afficher(“mon soleil”);

Soit la function somme qui retourne la somme de 2 nombres passes en arguments

public static intsomme(int a, int b){

returna+b;

Dans la fonction principale main() on appelle la fonction somme() en faisant

Double som= somme(5,9) ;

Exemple

Ecrire un programme java qui affiche les n premiers nombres de la suite de fibonacci.

Ecrire la fonction fibonacci()

Ecrire la fonction saisirEntier() qui a pour argument le message à afficher

qui retourne le nombre saisi après affichage du message passé en argument.

Dans le programme principal, afficher les n premiers nombre de la suite de

fibonacci en utilisant les 2 fonctions.

11
 VII- Les boîtes
Pour créer une interaction avec l’utilisateur on peut utiliser des boites.
- La boîte de message

Syntaxe

[Link](null, "<message>");

Exemple

[Link](null, "bonjour");

- La boîte de saisie

Illustration

String var= [Link](args);

NB: il faut importer la classe import [Link];

VIII- Conversion des types

- Un string en entier
Syntaxe

Int <var>= [Link](String <var2>) ;

Exemple

String sn="2";

int n = [Link](sn);

- Un string en double
Syntaxe
Double <var>= [Link](String <var2>) ;
Exemple
String sn="2";
double n = [Link](sn);

12
 exemple
ecrire un programme java qui affiche dans une boîte la somme de nombres entiers saisis à l’aide de
boîte.
package exemple;

import [Link];
public class Exemple {
public static void main(String[] args) {
String sn1= [Link]("Entrez le nombre 1");
int n1= [Link](sn1);
String sn2= [Link]("Entrez le nombre 2");
int n2= [Link](sn2);
intsom=n1+n2;
[Link](null, "la somme de "+n1+ " et de "+n2+" est
"+ som);
}
}

13
Atelier N°1 : Edition – compilation – Exécution
Enoncé
Cet atelier doit permettre à l’étudiant de créer un projet Java sous NetBeans, éditer une classe , la compiler
enfin l’exécuter

TAF
1- Téléchargerjdk et netBeans vous trouverez le lien
[Link]
[Link]
2- Installer le JDK
3- Installer NetBeans
4- Lancer NetBeans (demarrer ->NetBeans ->NetBeans)
5- Créer un projet
1. File ->new project ->java -> java application ->

Remplir la fenetre en indiquant le nom du projet , l’emplacement du dossier

de travail. Ajouter la classe principale oui ou non et le nom de cette classe.

14
1

2. Editer le programme
3. Compiler le runcompile file
4. Executer le fichier runrun file
5. Ajouter une nouvelle classe dans ce projet . pour ajouter une nouvelle classe
cliquer droit sur le package 1  nouvelle  classe et donner un nom à la
classe.

15
Chapitre II : Programmation Orientée Objet

I- La classe
Une classe java a la syntaxe suivante :

public class NomClasse {

//definition des attributs
<visibilité><type><attribut>;
<visibilité><type><attribut>;
<visibilité><type><attribut>;
....

//definition des contructeurs de la classe

public NomClasse(){
definition du contructeur
}

// definition des opérations de la classe

<visibilité><type><operation>([<type><arg>,...]){
definition de l'operation
}
<visibilité><type><operation>([<type><arg>,...]){
definition de l'operation
}

II- L’instanciation
On crée une instance de classe à l’aide de la syntaxe
<classe><instance>= new <constructeur> ;

III- Exemple
Enoncé
On souhaite écrire un programme java qui nous permettra de créer une facture . cette facture
comporte des lignes.
TAF
1- Créer un projet java , nommer le prjFacture
2- Ajouter une classe java et définir la classe Ligne dont le modèle est le suivant

16
 a. Ajouter une classe nommer la Ligne dans le package prjfacture
b. Ajouter les attributs de la classe , les attributs etant privés on leur precede du mot clé
private

/**
* le nimero de la ligne
*/
private int numero;
/**
* la designation de l'article de la ligne
*/
private String designation;
/**
* le prix unitaire de l'article pour cette facture
*/
private double prixUnitaire;
/**
* la quantité d'article commandée pour cette facture
*/
private int quantité;
c. Ajouter le constructeur de la classe. Ce constructeur doit nous permettre de saisir les
valeurs des attributs d’un objet lors de sa création.

17
public Ligne(){
/**
* definition du constructeur qui doit permettre de saisir le
numero,
* la designation, le prix unitaire et la quantité
*/
/**
* on crée un objet de scanner qui va nous permettre de
recuperé le resultat
* du flux entrant
*/
Scanner sc = new Scanner([Link]);
[Link]("***Entrez les données de la ligne SVP***");
[Link]("Numero: "); numero=[Link]();
[Link]("Designation: "); designation=[Link]();
[Link]("Prix Unitaire: ");
prixUnitaire=[Link]();
[Link]("Quantité: "); quantité=[Link]();
[Link]("***MERCI***");

d. Ajouter les accesseurs de la classe

public int getNumero(){

return numero;
}
public String getDesignation(){
return designation;
}
public double getPrixUnitaire(){
return prixUnitaire;
}
public int getQuantité(){
return quantité;
}

e. Ajouter les modifieurs de la classe

public void setNumero(int numero){

[Link]=numero;
}
public void setDesignation(String designation){
[Link]=designation;
}
public void setPrixUnitaire(double prixUnitaire){
[Link]=prixUnitaire;
}
public void setQuantité(int quantité){
[Link]é=quantité; }

f. Ajouter les operations. Total() retourne la quantité fois le prix unitaire, remise()
retourne 1000FCFA si le total est superieur à 100000FCFA sinon retourne 0FCFA. Le
netAPayer() retourne la somme de total() et remise().

public double total(){

18
 return prixUnitaire*quantité;
}
public double remise(){
if (total()>100000) return 1000;
else return 0;
}
public double netAPayer(){
return total()+remise();
}
g. Finalement le fichier [Link] sera

import [Link];
public class Ligne {
/**
* le nimero de la ligne
*/
private int numero;
/**
* la designation de l'article de la ligne
*/
private String designation;
/**
* le prix unitaire de l'article pour cette facture
*/
private double prixUnitaire;
/**
* la quantité d'article commandée pour cette facture
*/
private int quantité;
/**
* Constructeur de la classe
*/
public Ligne(){
/**
* definition du constructeur qui doit permettre de saisir
le numero,
* la designation, le prix unitaire et la quantité
*/
/**
* on crée un objet de scanner qui va nous permettre de
recuperé le resultat
* du flux entrant
*/
Scanner sc = new Scanner([Link]);
[Link]("***Entrez les données de la ligne
SVP***");
[Link]("Numero: "); numero=[Link]();
[Link]("Designation: "); designation=[Link]();
[Link]("Prix Unitaire: ");
prixUnitaire=[Link]();
[Link]("Quantité: "); quantité=[Link]();
[Link]("***MERCI***");
}
/**
* les accesseurs de la classe
* @return
*/
public int getNumero(){
return numero;
}
public String getDesignation(){
return designation;
19
 }
public double getPrixUnitaire(){
return prixUnitaire;
}
public int getQuantité(){
return quantité;
}
/**
* les accesseurs de la classe
* @param numero
*/
public void setNumero(int numero){
[Link]=numero;
}
/**
* modifieurs de la designation
* @param designation
*/
public void setDesignation(String designation){
[Link]=designation;
}
/**
* modifieur du prix unitaire
* @param prixUnitaire
*/
public void setPrixUnitaire(double prixUnitaire){
[Link]=prixUnitaire;
}
/**
* modifieur de la quantité de la ligne
* @param quantité
*/
public void setQuantité(int quantité){
[Link]é=quantité;
}
/**
* le total d'un article le nombre acheté par le prix unitaire
* @return
*/
public double total(){
return prixUnitaire*quantité;
}
/**
* la remise sachant qu'il est de 1000 FCFA si le total de
l'article e
* est superieur à 100000 FCFA
* @return
*/
public double remise(){
if (total()>100000) return 1000;
else return 0;
}
/**
* le net à payer pour l'article
* @return
*/
public double netAPayer(){
return total()+remise();
}

}
3- Dans la classe principale , crée 2 objets de Lignes
20
Ligne ligne1= new Ligne();

- afficher la désignation la quantité le prix unitaire, la quantité , le net à payer de chaque ligne

- Afficher le total de la facture qui est la somme des nets à payer de chaque facture puis la tva qui est
18% de ce total enfin le ttc de la facture

4- Les vecteurs

Définition

une tableau est un objet java de longueur statique, c'est-à-dire que le nombre d'éléments qu'il peut contenir
est fixe !!!
un Vector est un tableau dynamique (genre liste chainée ou autre), c'est à dire que sa longueur fixée
initialement à 10 est variable et non statique. ceci implique qu'il est conseillé d'utiliser des Vector plutôt
que des tableaux. En effet dans un tableau on est obligé de fixer une longueur optimale et donc réserver un
espace mémoire conséquent, avec un Vector cet allocation est minimale et réajustable à tout moment !!!
De plus l'utilisation de tableaux est déconseillée car elle ne s'inscrit pas dans la philosophie de l'approche
objet (tout objet) de Java.

Utilisation

Parmi les constructeurs disponibles, l'un n'attend aucun paramètre, l'autre attend une taille initiale en
paramètre. On construira donc un objet vect de la classe Vector en écrivant simplement:

21
 Vector <identifiant_vect>=new Vector();

ou

Vector <identifiant_vect>==new Vector(n);

pour prévoir une capacité initiale de n.

Ajouter un objet

On ajoute un objet à la fin du Vector en utilisant la méthode addElement. Par exemple, pour ajouter
l'objet o, on écrira :

[Link](o);

Le premier élément ajouté a l'indice 0, le suivant l'indice 1, etc... La méthode size() renvoie le nombre
d'éléments contenus dans le vecteur qui sera aussi l'indice du prochain objet ajouté.

Lire un objet

On retrouve un objet à partir de son indice en utilisant la méthode elementAt. Par exemple on obtient
l'objet d'indice n en écrivant :

o=[Link](n);

Attention, la méthode elementAt renvoie par défaut des objets de type Object, un transtypage est
souvent nécessaire. Par exemple, si l'élément d'indice 2 est de type String, il faudra écrire :

Color c=(Color)[Link](2);
Autres méthodes

La classe Vector contient de nombreuses autres méthodes qui rendent son utilisation très aisée. Notons
:

 contains(Object) : indique si l'objet est contenu dans le Vector.

 copyInto(Object[]) : copie les éléments dans un tableau classique.
 firstElement() : renvoie le premier élément.
 indexOf(Object) : renvoie l'indice de l'objet
 insertElementAt(Object, int) : insère l'objet à l'indice indiqué
 isEmpty() : indique si le Vector est vide
 lastElement() : renvoie le dernier élément
 removeAllElements() : vide le Vector
 removeElementAt(int) : retire l'objet dont l'indice est donné
 setElementAt(Object, int) : place l'objet à l'indice donné
 size() : renvoie le nombre d'éléments

a- ajouter une nouvelle classe dans votre projet nommer VecteurLigne

déclarer une instance de vecteur d’objet Ligne appelé cette instance liste

Vector <Ligne>liste =new Vector();

b- écrire une procédure qui permet d’ajouter une liste dans un vecteur de ligne tant que l’utilisateur

22
 public static void remplir(Vector<Ligne> v){
char rep;
Scanner sc = new Scanner([Link]);
do{
Ligne l= new Ligne();
[Link](l);
do{
[Link]("Voulez vous ajouter une nouvelle ligne
o\n?");
rep=[Link]().charAt(0);
}while (rep!='o'&&rep!='O'&& rep!='n'&&rep!='N');

}while (rep=='o'|| rep=='O');

}
c- ecrire une procedure qui lire les lignes du vecteurs. Pour chaque ligne on doit afficher le numero, la
designation, le prix unitaire , la quantite, le total , la remise et le net à payer

public static void lister(Vector<Ligne> v){

for(int i=0;i<[Link]();i++){
[Link]("les lignes de la facteur sont :");
[Link]("Numero :" + [Link](i).getNumero());
[Link]("Designation :" + [Link](i).getDesignation());
[Link]("Prix Unitaire :"+ [Link](i).getPrixUnitaire()+" FCFA");
[Link]("Quantité :"+ [Link](i).getQuantité());
[Link]("total :"+[Link](i).total()+" FCFA");
[Link]("remise :"+ [Link](i).remise()+" FCFA");
[Link]("Net à Payer :"+ [Link](i).netAPayer()+" FCFA");
[Link]("-------------------------------");

}
}
d- ecrire une fonction qui retourne le total des lignes d’une facture qui est la somme des net à payer de
chaque ligne.

e- dans la fonction on peut appeler les differentes fonctions comme ceci :

public static void main(String[] args) {

Vector <Ligne>liste =new Vector();
remplir(liste);
lister(liste);
}
}

f- ecrire une fonction qui retourne la tva de la facture

23
24
g- ecrire une fonction qui retourne le ttc de la facture, dans la fonction principale afficher le ttc de la
facture

h- ecrire une fonction qui retourne la ligne dont l’article a été le moins commandé c'est-à-dire qui la
quantité la plus petite. Dans le programme principal affiche la designation et la quantité de la ligne

i- ecrire une fonction qui supprime une ligne dont ont sait le numero et afficher la liste des lignes puis le
nouveau TTC dans la fonction principale.

25
Chapitre III : Accès aux Base de données cas de MySQL
I- Création de la base de donne bdFacture
a. Soit le shema de la base de données

Client(numClient : entier, nomClient :chaine(32), prenom : chaine(64),

telephone : chaine(14))

Facture(numFacture :entier, dateFacture : date, remise :reel,

#numClient :entier)

Ligne(numLigne : entier, designation : chaîne(64), prixUnitaire :reel,

quantite :entier,#numFacture :entier)

i. Implementer la base de données , nommer la base de donnée bdFacture

1. Lancer MySQL
a. Lancer EasyPHP puis la page d’administration

b. Créer la base de données bdFacture puis cliquer sur créer

c. Créer les tables
i. Entrer le nom de la table et le nombre de colonnes (champs)
puis executer

26
 ii. Definir la structure de la table

Entrer le nom du champ , le type si c’est un varchar il faut obligatoirement indiquer la taille de la
colonne.

Dans la colonne Index indiquer si le champ est clé primaire , cocher autoincrement si vous souhaiter que
le sgbd créer la valeur de la colonne. On ne peut faire une colonne autoincrement si elle est clé primaire
et entier.

27
Cliquer sur sauvegarder si vous avez fini la definition de la table pour enregistrer la table.

Ajouter une nouvelle table .exemple ajouter la table Facture

Definirles colonne de la table

28
 Si on a une clé etrangère comme le cas de numClientdefinir cette clé comme INDEXE.
Faire de même pour créer la table Ligne.
d. Créer les relations

Cliquer sur concepteur pour faire les relations entre les tables.

II- Ouvrir le serveur de Base de données sous NetBeans

a. Dans l’onglet service connecter vous au server Mysql
29
b.
Cliquer droit sur le pilote Mysqlconnectusing et remplir le formulaire suivant

c.
Enter le nom de la base de base de données bdFacture puis cliquer sur Finish
Vous devez avoir l’arborescence suivante :

30
31
III- Realisation du GUI
a. Créer un projet Java et nommer prjBdFacture
b. Ajouter une fenetre principale à votre paquetage prjbdfacture et nommer le FrmPrincipal
Cliquer droit sur le paquetage new other

c. Modifier la barre des menus

Nommer les menus pour avoir l’arborescence suivante

d. ajouter des fenetres internes

ajouter une fenetre interne (glisser deposser une internal Frame) sur le desktop de la
frmPrincipal et dessiner

32
Modifier les noms pour avoir l’arborescence suivante

33
 Pour modifier le contenu de la table  cliquer droit  table content et modifier les colonnes
et les lignes.

e. Faire les interface de FrmFacture

f. Faire l’interface FrmLigne

34
 g.
IV- Programmer les interfaces
a. Rendre les fenetres internes invisibles
b. A l’evenementactionPerformed du mnuClientEdition, il fautrendre visible la fenetreFrmClient
[Link](true) ;

faire de même pour les autres fenetres

c. Ajouter une nouvelle classe à votre paquetage et nommer la Mysql. Cette classe nous
permettra de definir notre connection à la source de données.
La source de la page est

import [Link];
import [Link];
import [Link];
public class Mysql {
private String pilote="<driver>";
private String url="<url>";
private String utilisateur="<utilisateur>";
private String password="<motde passé de l’utilisateur>";
public Connectionma_connexion=null;
public Mysql(){
try{
[Link](pilote);
ma_connexion = [Link](url,utilisateur,"");
}
catch(ClassNotFoundException cl){}
catch(SQLException se){}
}
public void fermer() throws SQLException{
ma_connexion.close();
}
}

d. Ajouter une classe metier [Link]. dans cette classe on trouvera toutes les opérations
standards de manipulations de la table Client. Comme insertion, modification, suppression,
liste des données…

package prjbdfacture;

import [Link];
import [Link];
import [Link];
public class Client extends Mysql{
Statement mon_statement=null;
public Client(){ }
public String inserer(String nom, String prenom, String
telephone){
try{
mon_statement = ma_connexion.createStatement();
//definir la requete
String requete= "INSERT INTO
Client(nomClient,prenomClient,telephone) VALUES
('"+nom+"','"+prenom+"','"+telephone+"')";

35
mon_statement.executeUpdate(requete);
return "insertion ok";
}
catch(SQLException se){
return [Link]();
}
}
public ResultSetconsulter(){
ResultSet RS=null;
try{
mon_statement = ma_connexion.createStatement();
String requete="select * from Client";
RS= mon_statement.executeQuery(requete );
}
catch(SQLException se){
RS=null;
}
return RS;
}
public intnombre(){
ResultSet RS=null;
try{
mon_statement = ma_connexion.createStatement();
String requete="select count(*) as nbre from Client";
RS= mon_statement.executeQuery(requete );
[Link]();
return [Link]("nbre");
}
catch(SQLException se){
return 0;
}
}
public String modifier (intnumero, String
nom,Stringprenom,String telephone){
try{
mon_statement = ma_connexion.createStatement();
//definir la requete
String requete= "UPDATE CLIENT SET nomClient='"+ nom
+"',prenomClient='" + prenom+"',telephone='"+telephone+"'
WHERE numClient="+numero ;
mon_statement.executeUpdate(requete);
return "modification réussie";
}
catch(SQLException se){
return [Link]();
}
}
public String Supprimer (intnumero){
try{
mon_statement = ma_connexion.createStatement();
//definir la requete
String requete= "DELETE FROM Client WHERE
numClient="+numero ;
36
mon_statement.executeUpdate(requete);
return "modification réussie";
}
catch(SQLException se){
return [Link]();
}
}
}

e. Ajouter la bibliothèque MySQL JDBC Driver à votre projet.

Cliquer droit sur  bibliothèque  ajouter une bibliothèque  choisir MySQL JDBC Driver
cliquer sur Ajouter

Verifier si la bibliothèque est correctement ajoutée.

III- Programmer l’interface

a- A l’evenement click du bouton btEnregistrerClient
- il faut recuperer les informations saisies dans les differents champs de text.

String nom=[Link]();
String prenom=[Link]();

37
 String telephone=[Link]();

- Créer un objet de client nommer le client

Client client= new Client();

- Appeler la methodeinserer en passant les arguments à cette operations.

String insertion=[Link](nom, prenom, telephone);

[Link](this, insertion);

b- Verifier dans la table si l’enregistrement a été réalisé.

c- Afficher dans la table la liste des clients existants
- Ecrire une fonction remplir qui nous permet de remplir la table.

public voidremplir(){
DefaultTableModel md = new DefaultTableModel();

[Link](new String
[]{"Numero","Nom","Prenom","Adresse"});

Client client=new Client();

//effacer le contenu
[Link](0);
[Link](md);
//lister la requete
ResultSetrs=[Link]();
try {
while ([Link]()){
/*---------------------- AJOUT DES LIGNES AU JTABLE ----------------
----*/
[Link](new
Object[]{[Link]("numClient"),[Link]("nomClient"),[Link]
ect("prenomClient"),[Link]("telephone")});
[Link](md);
}
} catch (SQLException ex) {
[Link]([Link]()).log([Link], null,
ex);
}
/*---------------------------------- AFFECTER LE MODEL AU JTABLE avec
la methodesetmodel ------------*/

}
- Appeler cette fonction lorsqu’on finit unenregistrement

- Appeler cette fonction lorsqu’on charge la fenetre interne

38
 - A l’evenement click de la table, les champs de texte doivent afficher l’enregistrement
selectionné. C'est-à-dire que txtNumeroClient doit le afficher le numéro, txtNomClient
doit afficher le nom du client …

- Ajouter l’operationrechercher(intnumero) à la classe Client. Cette operation retourne

la ligne dont le numero client est le numero de l’argument.

public ResultSetrechercher(intnumero){
ResultSet RS=null;
try{
mon_statement = ma_connexion.createStatement();
String requete="select * from Client where
numclient="+numero;
RS= mon_statement.executeQuery(requete );
}
catch(SQLException se){
RS=null;
}
return RS;
}

- Ajouter la fonction remplirChamp(intnumero) qui permet d’afficher dans les champs

de texte de FrmClient les informations de la ligne

public voidremplirChampsTexte(intnumero){
Client client=new Client();
ResultSetrs= [Link](numero);
try {
if ([Link]()){
[Link](""+[Link]("numClient"));
[Link]([Link]("nomClient"));
[Link]([Link]("prenomClient"));
[Link]([Link]("telephone"));

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

39
 - A l’evenement click de la jTable, il faut afficher les données de la ligne

introwIndex = [Link]();
//intcolIndex = [Link]();
String selection=[Link](rowIndex, colIndex).toString();
remplirChampsTexte([Link](selection));

- A l’evenement click du bouton btModifierClientmodifier la ligne

//créer l’objet
Client client = new Client();
//recuperer les donnees
String numero=[Link]();
String nom=[Link]();
String prenom=[Link]();
String telephone=[Link]();
int rep;
rep=[Link](this, "Voulez-vous modifier
l'enregistrement");
if (rep==JOptionPane.YES_OPTION){
//on modifie la ligne
[Link]([Link](numero), nom, prenom, telephone);
[Link](this, "modification OK");
//on rafarîchit la grille
remplir();
}

- a l’venement click du bouton btSupprimerClient on doit supprimer l’enregistrement

Client client = new Client();

String numero=[Link]();
intrep;
rep=[Link](this, "Voulez-vous supprimer
l'enregistrement");
if (rep==JOptionPane.YES_OPTION){
[Link]([Link](numero));
[Link](this, "Suppression OK");
remplir();
}

ajouter une nouvelle fenetre interne FrmFacture et dessiner

40
modifier les noms pour avoir l’arborescence suivante

41
- rendre la fenetre invisible
- a l’evenementactionPerformed du menu mnuEditionFacture il faut afficher la fenetre
le champs de texte txtNumeroClientFacture doit afficher le numero du client de la fentre Client.

- reprendre les mêmes opérations que la fenetreFrmClient

42
Chapitre II : L’héritage

I- Contexte

Enoncé

Soit le modèle suivant :

TAF
1- Définir le package et les classes Cercle et Cylindre.
2- Dans le programme Test, définir les objets suivants
cr : Cercle
Id=1
Rayon=5

cy : Cylindre
Id=2
Rayon=10
Hauteur=5

Remarques

43
La classe Cylindre est entièrement cohérente avec la classe Cercle, elle a les membres que la classe Cercle. On
peut donc créer la classe Cylindre a partir de la classe Cercle. On dira que la classe Cylindre hérite de la classe
Cercle. Le concept POO qu’on définira est l’héritage.

II- Définition de l’héritage

L’héritage est l’un des concepts les plus puissants de la programmation orientée objet. Elle permet de définir à
partir d’une classe A (classe de base) une ou plusieurs classes B, C,..(classes dérivées).

La classe dérivée est entièrement cohérente avec la classe de base. A partir de l’héritage, la classe dérivée a :

- Tous les membres de la classe de bases (attributs ou opérations)

- Toutes les associations (une instance de la classe dérivée peut être appelée dans toutes fonctions ou
opérations ou une instance de la classe de base est appelée)
Représentation

Syntaxe Java

Le mot clé extends permet de dériver la classe A

44
 TAF
1- Redéfinir le modèle précédent
Dans la classe Cylindre on aura seulement les spécificités d’une instance de Cylindre c'est-à-dire
hauteur et volume()

2- Modifier la source de la classe Cylindre

La source de [Link]

45
46
La source de [Link]

3- Tester
a- Créer l’objet de cylindre

b- Afficher la base du cylindre

47
 c- Ajouter la methode toString() à la classe Cylindre et qui doit retourne l’id, le rayon et la hauteur,
n’utiliser pas les getters . Que constatez vous

Nb : les membres privés d’une classe de base ne sont pas accessibles par les classes dérivées.

d- Définir la visibilité des attributs de Cercle en protected

Nb : pour que les membres que l’on juge privé soient accessibles par les classes dérivées, il faut définir ces
membres protected

Exercice

Soit le modele suivant

Définir les classes du modèles avec des constructeurs défauts et initialisation, getter/setter

Dans un programme de test, créer des objets de Ligne et de LigneAvecRemise afficher le total pour chaque
ligne

Source de [Link]

48
Ajouter ici le code source de la classe

Source de [Link]

Ajouter ici le code source de la classe

Source de [Link]

Ajouter ici le code source de la classe

Capture de l’écran d’exécution

Ajouter l’image capture de test

On modifie le modèle précédent et on

49
- Ajouter la classe Facture. Dans la classe facture
o L’id de la facture doit être automatique, de même que ceux des lignes
o Déclarer un attribut privé lignes qui est de type List<Ligne>
o Initialiser cet attribut dans chaque constructeur de Facture
o L’opération ajouter() : prend une ligne en paramètre et l’ajoute à lignes
o Supprimer() : supprime la ligne passée en argument de lignes
o Modifier() : modifier les valeurs des attributs de l’objet qui a l’id en paramètre
o totalHorsTaxe() retourne la valeur des sommes des total() de toutes les lignes de la facture
o totalRemise() retourne la valeur des sommes des remise() de toutes les lignes avec remise
o tva() retourne la valeur de la Tva de la facture
o ttc() retourne la valeur de l’expression totalHorstaxe+Tva-remise
o getNombreLigneRemise retourne le nombre de lignes qui est de type LigneAvecRemise
o afficher doit afficher la facture suivant le modèle suivant
facture N° [id]
date : [dateFacture]
client : [client]
detail
50
 id designation prix unitaire quantité total remise
[id] [designation] [prixUnitaire] [quantité] [total] [remise]
[id] [designation] [prixUnitaire] [quantité] [total] [remise]
[id] [designation] [prixUnitaire] [quantité] [total] [remise]
………
[id] [designation] [prixUnitaire] [quantité] [total] [remise]

Totaux
Total Hors taxe : [totalHorsTaxe]
Tva[TauxTva] : [Tva]
Remise : [remiseTotal]
[Nbre Ar. Remise] : [nombre Article Remise]

- ajouter une classe Test, et faire les operations suivantes

o créer une facture
o ajouter 7 lignes dont 4 ligne et 3 ligneavec remise
o afficher la facture
o supprimer la ligne avec remise qui a la plus grande remise
o afficher la facture
o rajouter la ligne supprimer et modifier son taux par celui de la ligne qui le plus petit taux
o afficher la ligne

Donner la source de [Link]

Ajouter ici le code source de la classe

Donner la source de [Link]

Ajouter ici le code source de la classe

Capture de l’écran d’exécution

Ajouter l’image capture de test

51
 La classe Final

Définition

Une classe final est une classe qui ne peut avoir de classes dérivées.

Exemple : modifier la déclaration de la classe Ligne en la déclarant de type final

public final class Ligne {

Que constatez-vous ?

52
Chapitre III : Le polymorphisme

I- Portée des membres d’une classe

Dans cette section, on parlera de la portée d’un membre d’une classe.

Exemple

1- soit les classes suivantes A et B dont la source est

source de A

Et la source de B

Ajouter une classe de Test

Test 1 : quel est le resultat de la source suivante

Votre résultat

Votre commentaire

53
Test2 : quel est le résultat de la source suivante à l’exécution

Apporter votre commentaire

Test3 : quel est le résultat de la source suivante

Donner le sorties du programme

Donner votre commentaire

54
Test4 : quel est le résultat de la source suivante

Donner le résultat

Donner votre commentaire

Test 5 : donner le résultat de la source suivante

Donner le résultat

55
Donner votre commentaire

Test 6 : Donner le résultat de la source suivante

Donner le résultat

Donner votre commentaire

Test 7 : donner le résultat de la source suivante

Donner votre résultat

Donner votre commentaire

56
Test 8 : donner le résultat à la sortie de la source suivante

Donner votre résultat

Donner votre commentaire

II- définition

Le polymorphisme désigne la capacité, pour un objet donné, d'invoquer des opérations sur un objet dont il ne
connait pas la nature. Autrement dit, le polymorphisme d'objet consisterait à permettre à des objets de
présenter une interface similaire.

III- la redéfinition de méthode

1- Définition
Une fonction ou méthode a 3 temps :
o la déclaration : donner une signature (identifiant, argument, type retourné) ;
o la définition : corps de la fonction ;
o appel : invocation de la fonction par une autre fonction.

Redéfinir une méthode, c’est de récrire une méthode existante dans la classe de base avec la même signature
dans les classes dérivée mais avec une nouvelle définition.

Surcharger une méthode, c’est réécrire une méthode dans la classe de base ou dérivée avec une signature
différente.

2- Exemple

57
Evaluation

Soit l’énoncé suivant :

Pour la gestion des admissions des étudiants on vous demande de mettre en place une model répondant aux
règles suivantes :

Notre système a deux types d’étudiants ceux inscrits au cycle BTS et ceux du cycle Ingénieur. Un étudiant du
BTS a un id, un matricule, un nom, une date de naissance, une moyenne général et est admis. Il compose et on
souhaite avoir les informations sur l’étudiant comme son id, nom, prénom, date de naissance, la moyenne
général, est admis ou pas. Lorsqu’il compose on passe en argument la moyenne générale. Si cette moyenne
est supérieure ou égale à 10 admis est vrai sinon faux.

L’étudiant du cycle ingénieur a comme celui du BTS un id, un matricule, un nom, une date de naissance, une
moyenne général et est admis mais un sujet de soutenance et la note de soutenance. Il est évalué et on passe
sa moyenne générale en paramètre alors sa moyenne générale est modifiée. Il compose également mais on
passe en argument la note de soutenance et la note de soutenance est modifiée. Si la moyenne de la moyenne
générale et celle de la note de soutenance est supérieure à 10 alors il est admis.

Qu’il soit BTS ou Ingénieur, l’appréciation s’applique sur la moyenne générale et est :

- nulle pour une moyenne générale est en dessous de 5

- faible pour une moyenne supérieure ou égale à 5 et inferieure à 10
- passable pour une moyenne de 10 à 12
- assez bien entre 12 et 14
- bien entre 14 et 17
- très bien au delà de 17

NB : la moyenne générale, la note de soutenance et est admis ne sont modifiés qu’à partir des seuls
traitements validés, composer.

TAF

1- donner le modèle (/8)

2- donner la source des classes (/8)

3- donner la source de la classe [Link] (/4)

o créer un objet de BTS
o créer un objet d’Ingénieur
o l’ingénieur est évalué et reçoit 12
o le BTS compose et obtient 11
o l’ingénieur compose et obtient 13

58
 o afficher les informations sur l’ingénieur et le BTS

A demain pour la suite du cours et encore Merci.

Recommandation
1- modèle 1

On peut considérer la classe EtudiantBTS comme la classe de base et la classe EtudiantIngenieur comme la
classe dérivée. Proposer un modèle.

- Donner la source de la classe [Link]

- Donner la source de la classe [Link]

Une instance de EtudiantIngenieur compose mais la définition de méthode composer() de la classe de base
sera différente. Alors on redéfinira dans la classe EtudiantIngenieur la methode.

Lorsque l’instance de EtudiantIngenieur invoque la méthode composer(), c’est la méthode qui se trouve dans
la classe EtudiantIngenieur qui est appelé et non celle de la classe de base. On dit que la méthode de la classe
de base est masquée.

Redéfinir la méthode toString() dans la classe EtudiantIngenieur en appelant la méthode de toString() de la

classe de base.

Que constatez-vous ?

Lorsque vous souhaitez invoquer dans une classe dérivée un membre de la classe de base masqué. Utilisez le
mot clé super

Syntaxe

59
[Link]

Donner la source de la classe [Link]

NB : L’annotation @Override permet d’indiquer que la méthode est une méthode redéfinie.

3- La méthode final

Une méthode déclarée final est une méthode qu’on souhaite ne pas redefinir dans les classes dérivées.

Syntaxe

<visibilite> final <type> <identifiant>(<type> <argument>,….){

…definition
}

Exemple :

Dans la classe EtudiantBTS, mettre la méthode composer() a final.

public final void composer(){

…ajouter la definition
}

Que constatez vous ?

IV- La méthode abstraite

1- Définition

Une méthode abstraite est une méthode d’une classe de base dont l’implémentation sera faite dans les classes
dérivées.

En d’autre terme, on prévoit qu’une méthode doit exister dans une classe mais son implémentation n’est pas
connu donc toutes les classes qui dériveront de cette classe doit obligatoirement implémenter cette méthode.

2- Syntaxe

<visibilite>abstract <type><identifiant>(<type> <argument>) ;

3- Exemple

public abstract void composer(double moyenne) ;

60
 V- La classe abstraite

1- Définition

Une classe abstraite est une classe qui possède une ou plusieurs méthodes abstraites. S’il existe une seule
méthode abstraite dans une classe alors celle-ci devient abstraite.

2- Syntaxe

<visibilité> abstract class <identifiant>{

…..corps

NB : On utilise souvent les classes abstraites pour regrouper (factoriser) les membres communs de plusieurs
classes.

3- Exemple

Reprendre l’exemple précédent

Model2 : Utiliser des classes abstraites

- Modifier le modèle,

Créer une classe de base Etudiant qui a les membres communs aux deux classes et dériver cette classe pour
avoir les classes filles Ingenieur et BTS. La classe Etudiant aura la methode abstraite composer() car la
definition de cette methode est differente qu’on soit Ingenieur ou BTS.

61
En UML, la methode et la classe abstraite sont en italique.

- Source de la classe [Link] (source partielle que vous completerez)

NB : la methode toString() doit afficher les valeurs des attributs , la valeur de l’operation estAdmis et
l’appreciation de la moyenne.

Source de la classe [Link]

Coller ici la source de la classe

62
 - Dans la classe Test.

Créer un objet de la classe Etudiant

Que constatez-vous ?

Ajouter votre commentaire

- Donner la source de la classe BTS, elle doit obligatoirement redefinir la méthode composer().

Source de la classe BTS

Coller ici la source de la classe

- Dans le programme Test , créer un objet de la classe BTS, invoquer sa méthode composer, afficher ses
informations.

Coller ici la source de la classe

Coller ici la capture de l’ecran de sortie

- Donner la source de la classe Ingenieur, elle doit obligatoirement redefinir la méthode composer(),
dans la classe ingenieur redefinir la méthode toString() en invoquant la méthode toString() de la classe
de base et la compléter pour retourner les valeurs des attributs spécifiques de la classe Ingenieur

Source de la classe Ingénieur

Coller ici la source de la classe

- Dans le programme Test, créer un objet de Ingenieur, invoquer sa méthode composer et afficher ses
informations.

Coller ici la source de la classe

Coller ici la capture de l’ecran

63
Exercice

Soit le modèle suivant

Les attributs dérivés notés -/ sont des attributs qui sont obtenus à partir d’autres opérations. Concrètement ils
n’auront pas de setter mais les getters retourneront le résultat d’une opération.

Exemple :

Premier n’aura pas de setter mais un getter qui retournera l’étudiant qui la plus faible moyenneGenerale.

TAF

- Ajouter la classe Classe

- Elle aura une liste d’Etudiant
- Dans le programme principal, créer 2 classes ; ajouter dans la classe 1 deux objets de BTS et dans la
classe 2 deux objets d’ingenieur
- Pour la classe d’ingenieur afficher le dernier de la classe
- Pour la classe de BTS afficher l’effectif et la moyenne de classe

64
65
 VI- L’interface
1- Définition

L’interface est une classe abstraite composée uniquement que de méthode abstraite. On dit que c’est une
classe abstraite pure. Elle a toutes les propriétés de la classe abstraite, sauf qu’elle n’utilise pas le mot clé
abstract.

2- Syntaxe

public interface I {
public <type> <identifiant>(<type> <arg>);
…
}

Toutes les méthodes de l’interface étant abstraites, on ajoute plus le mot clé abstract.

3- Héritage d’interface

Une interface peut dériver d’une autre interface

4- Syntaxe java

<Visisbilite> interface B extends I{

Une interface peut étendre plusieurs autres interfaces on note alors

<Visisbilite> interface R extends I, D{

Une classe peut implémenter une ou plusieurs interfaces et on note

Uml

66
En java

<Visisbilite> class X implements I{

La classe peut implémenter des interfaces et étendre une classe on note

Exemple : la classe implémente les interfaces I et D et étend la classe C

<Visisbilite> class X implements I, D extends C {

5- Exercice

Soit le modele suivant

67
L’interface Figure indique que toutes les classes qui vont lui dériver doivent obligatoirement implémenter ses
opérations.

TAF

1- Ajouter une interface et nommer la Figure

Source de [Link]

2- Editer les sources de [Link] et [Link]

Source de [Link]

Source de [Link]

68
Chapitre IV : java / swing
I- Objectif
Ce chapitre doit permettre de créer des fenêtres Windows, ajouter des composants et programmer les
événements de ces contrôles.

Lien :

Lisez le pdf du lien suivant :

[Link]
OOz5jOAhVBBBoKHe4hCP8QFggeMAA&url=http%3A%2F%[Link]-
[Link]%2F~elc%2Fswing%[Link]&usg=AFQjCNGDu1KK7xrw_4aEo6brLR0QKS_YTA

Puis nous ferions les ateliers

II- Atelier 1
Premier page JFrame.

Taf

1- Créer un projet nommer ProjetFenetre

2- Ajouter le package [Link]
3- Ajouter la classe Fenetre , cette classe doit étendre la classe [Link]

Source 1 de [Link]

4- Ajouter dans ce package la classe [Link]

- Créer un objet de la classe.

- Executer le propgramme

69
Que constatez vous ?

Les membres de la classe JFrame.

- La methode setVisible() : elle permet d’afficher une fenetre, ajouter dans la methode initialiser() dans
la classe Fenetre et invoquer l’operation setVisible() avec pour argument true.

Source 2 de fenetre avec la methode setVisible()

Executer la fonction Test

Que constatez-vous

Modifier la methode initialiser() de Fenetre.

Executer la classe [Link]

70
 5- Ajouter des composants à la fenetre
- Ajouter un bouton

Les boutons sont des objets de la classe JButton.

Source de [Link]

Executez

Que constatez-vous ?

Ajoutez un deuxieme bouton avec le texte Bonsoir à la fenetre.

71
import [Link];
import [Link];
import [Link];
public class Fenetre extends JFrame {
private JButton btn_salut;
private JButton btn_bonsoir;
public Fenetre(){
[Link]();
}
public void initialiser(){
[Link](true); // rendre la fenetre visible
[Link]("Ma premiere page"); // donner un titre à la fenetre
[Link](600, 400); // definir une taille de la fenetre
[Link](null); // centrer la fenetre
//creer un objet de JButton
this.btn_salut= new JButton();
//definir quelque propriété de butons
//creer un objet de JButton
this.btn_bonsoir= new JButton();
this.btn_salut.setText("Bonjour");
// [Link](new Dimension(50,20));
//definir quelque propriété de butons
this.btn_bonsoir.setText("bonsoir");
// [Link](new Dimension(50,20));
//ajouter le bouton à la fenetre
[Link](this.btn_salut);
[Link](this.btn_bonsoir);
[Link]();

Que constatez-vous ?

- Les layoutManagers

Les layoutManager perment de gerer la disposition sur le contrôle. Il existe plusieurs layoutManager . on peut
citer :

o AbsoluteLayout
o BorderLayout
o CardLayout
o FlowLayout
o GridBagLayout
o GridLayout
o NullLayout
72
 o OverlayLayout

Voir le lien [Link]

Dans cet exemple , nous utiliseront GridLayout il place les controles dans les cellules de la lignes donc vous
definirez le nombre de ligne et de colonnes, lorsqu’il remplir une ligne, il passe à la ligne suivantes.

Dans cet exemple on a deux boutons qui met dans chaque cellule de la ligne.

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

/**
*
* @author GNAGBO
*/
public class Fenetre extends JFrame {
private JButton btn_salut;
private JButton btn_bonsoir;
public Fenetre(){

[Link]();
}

public void initialiser(){

[Link](true); // rendre la fenetre visible
[Link]("Ma premiere page"); // donner un titre à la fenetre
[Link](600, 400); // definir une taille de la fenetre
[Link](null); // centrer la fenetre

//creer un objet de JButton

this.btn_salut= new JButton();
//definir quelque propriété de butons
//creer un objet de JButton
this.btn_bonsoir= new JButton();
this.btn_salut.setText("Bonjour");
// [Link](new Dimension(50,20));
//definir quelque propriété de butons
this.btn_bonsoir.setText("bonsoir");
// [Link](new Dimension(50,20));
//ajouter le bouton à la fenetre

//definir le layout de la fenetre

//nous choisissons GridLayout 1 ligne et 2 colonnes
[Link](new GridLayout(1, 2));
[Link](this.btn_salut);
[Link](this.btn_bonsoir);
[Link]();

}
73
}

Executez

Que constatez – vous ?

74
75
Atelier IV : JDBC
I- Objectif du document

Ce document doit permettre d’implémenter un projet JAVA interfaçant une base de données Oracle 10g
express.
Dans cet atelier l’auditeur doit créer un schéma de base de données, créer les objets de la base de données.
Ensuite créer un projet java, ajouter des interfaces utilisateurs , dessiner ces interfaces et programmer ces
instances.

II- Création de la base de données

1- Ouvrir une session avec le compte system

2- Créer le schéma java
a. Créer le tablespace permanent java_tbs

Ajouter ici la source

b. Créer le tablespace temporelle java_temp

Ajouter ici la source

c. Créer l’utilisateur java avec le mot de passe azerty sur les tablespace java_tbs et java_temp

Ajouter ici la source

d. Donner les rôles connect, resource à l’utilisateur java

Ajouter ici la source

3- Ouvrir une session avec java

a. Créer les tables
i. Tb_facture(id_facture :int, date_facture :date, client :chaine(48), date_creation :date)
Ajouter ici la source
ii. Tb_article(id_article :int, abr_article :chaine(8),prix_min :réel, stock :entier)
Ajouter ici la source

iii. Tb_ligne(id_ligne :int, #id_facture :int, #id_article :int, quantite :int, prix_unitaire :réel)
Ajouter ici la source

b. Créer les sequences

i. Seq_facture_id

Ajouter ici la source

76
 ii. Seq_article_id

Ajouter ici la source

iii. Seq_ligne_id

Ajouter ici la source

c. Créer pour chaque table

i. Créer le package pck_table et ajouter
- Sp_table_ajouter(parametre) : procédure qui permet d’ajouter un
tuple dans la base de données, vous ne devez pas avoir de paremetre
id_table et la date_création, l’id aura pour valeur la sequence
courante
- Sp_table_modifier (p_table_id, autres_colonne_table) qui permet de
modifier la ligne
- Sp_table_supprimer(p_table_id) qui permet de supprimer la ligne
- Sp_table_tous() qui retourne la liste de la table
- Sp_table_rechercher(p_table_id) qui retourne la ligne dont l’id est
p_table_id

Ajouter ici la source

III- Création du projet java

1- Créer le projet java nommer le ProjeJDBC
2- Ajouter le package [Link]

a. Ajouter les classes

[Link]

77
Ajouter ici la source

[Link]

Ajouter ici la source

[Link]

Ajouter ici la source

3- Ajouter le package [Link]

78
 a. Créer les classes du packages

[Link]

[Link]

Tester la connexion

79
Ajouter ici la source

Afficher l’ecran de sortie

Source du programme [Link]

Ajouter ici la source

Source de [Link]

Ajouter ici la source

Source de [Link]

Un apercu de la source de [Link]

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

public class ArticleHelper extends Connexion implements IArticle {

@Override
public String ajouter(Article article) {

String requete="{call pck_article.ajouter(?,?)}";

try{
//charger la requete
CallableStatement cs = [Link](requete);
//passer les valeurs des arguments de la procedure
[Link](1, [Link]());
[Link](2, [Link]());
//executer la procedure
[Link]();
return "Article ajouté";

}
catch(SQLException ex){
return [Link]();
}

80
 }

public List<Article> lesArticles() {

String requete="{call ?=pck_article.ajouter()}"; Commentaire [G1]: Adapter au nom

de votre procedure

try{
//charger la requete
CallableStatement cs = [Link](requete);
//recuperer la valeur de sortie de la procedure
[Link](1, [Link]);

// executer la procedure
[Link]();

// obtenir le cursor le convertir en resultSet

ResultSet rs = (ResultSet) [Link](1);

// parcourir le resultSet et créer une liste d'objet d 'article

List<Article> articles= new ArrayList<>();
while ([Link]()) {
Article a = new Article([Link](1), [Link](2), [Link](3), [Link](4));
[Link](a);
}
return articles;

}
catch(SQLException ex){
MSGERROR=[Link]();
return null;
}

}
}

Ajouter ici la source complete de votre classe

Tester les méthodes de la [Link]

Source de [Link]

Ajouter ici la source

Source de [Link]

81
Ajouter ici la source

Tester les méthodes de [Link]

Source de [Link]

Ajouter ici la source

Source de [Link]

Ajouter ici la source

Tester les methodes de [Link]

4- Ajouter le package [Link]

a. Ajouter la JFrame Form FormArticle et dessiner

b. Programmer l’interface

A l’evenement click du bouton Enregistrer,

Créer un objet de ArticleHelper

82
Créer un objet de Article

Invoquer l’opération ajouter de ArticleHelper.

5-

83
Chapitre II : JAVA / RMI

I- Objectif de l’atelier
Cet atelier nous permettra de présenter la technologie RMI et l’implémenter.

- Créer un programme serveur

- Créer un programme client
- Créer une base de données
- Créer le modèle
- ..

II- Présentation de la technologie

Le RMI permet d'appeler du code à distance. Plus précisément, nous allons exposer une
partie du code sur le client au travers d'interfaces. L'implémentation proprement dite se
trouvera du côté du serveur et le rôle de RMI sera de faire le nécessaire afin de lier les
interfaces aux implémentations distantes. En production nous aurons un JAR contenant
uniquement les interfaces et un autre les implémentations. Cette pratique nous permettra
d'importer uniquement les interfaces sur le client, et de déployer les implémentations sur
le serveur.

II-A.1-1- Fonctionnement

Afin de pouvoir lier l'implémentation présente sur le serveur avec les interfaces du
client il existe plusieurs alternatives. Nous pouvons générer des classes Java qui vont
implémenter les interfaces, se connecter au serveur, puis déléguer l'appel vers le serveur
au travers d'un socket.
Nous pouvons aussi éviter de générer du code grâce au proxy dynamique pour
rediriger l'appel du code client vers le serveur dynamiquement. Quelle que soit
l'alternative choisie nous voyons là émerger deux agents importants :

 L’objet côté client qui va rediriger l'appel vers le serveur (le Stub) ;
 L’objet côté serveur qui sera atteint par l'objet dynamique côté client (le
Skeleton).

84
 Fonctionnement de RMI
Un annuaire appelé registry nous permettra de publier les services au niveau du
serveur. Il associera une clé (un identifiant) à une instance publiée et accessible au
travers d'un socket.
Source : [Link]

2- Avantages

Les avantages de cet approche sont multiples mais nous en retiendrons principalement
deux :

 Le client peut être mis à jour de manière transparente puisqu'un simple

redéploiement au niveau du serveur permet de modifier le comportement du
client.
 L'exécution distante de la méthode est masquée au code client, le code
appelant travaillant avec les instances implémentant les interfaces comme si
l'exécution était locale.

III- TAF (créer le programme serveur)

1- Créer le programme serveur

2- On a le modèle serveur

85
3- Lancer la machine hôte créer un projet et nommer le ProjetRMI
a. Ajouter le package [Link]

i. Ajouter la classe [Link]

86
 ii. Ajouter la classe [Link]

La classe [Link] est l’interface qui permet de créer l’interface de contrat .

Tous les services ont une exception de RemoteException.

iii. Ajouter le package [Link].

87
- Editer la classe ImpRemote qui implémente l’interface TestRemote

- Editer la classe [Link]

(Voir le code ci-dessous)

88
89
TAF (créer le programme client)

1- Lancer la machine virtuelle

2- Créer un dossier nommer le clientRMI dans le dossier utilisateur
3- Créer le sous-dossier com/projetrmi/interfaces
4- Ajouter la classe Constantes comme dans celle du serveur
5- Ajouter la classe TestRemote comme dans celle du serveur
6- Ajouter dans le dossier clientRMI/ com/projetrmi / execution
7- Ajouter la classe [Link]

Mettre l’adresse de la machine serveur en lieu et place de [Link].

90
 Exercice1 : ajouter la méthode additionner(double, double) qui retourne la
somme des arguments passés en argument.

Interface

Coller la source de l’interface

Implémentation

Coller la source de la classe d’implémentation

Dans le client afficher la somme de 2 et 3.

Client

Coller la source de la classe [Link]

8- Sérialiser un objet

Si vous devez retourner des objets , il faut que vos classes implemente la classe
[Link]

Source de [Link]

Ajouter la methode retournerLigne() qui retourne l’objet

91
l1 :Ligne
id=1
designation=’’stylo’’
quantite=10
prixUnitaire=200

Modifier l’interface

Source de l’interface

Modifier l’implémentation

Source de la classe d’implémentation

Dans le client afficher les infos et le totalHors de l’objet à l’invocation de la méthode

retournerLigne()

Capture du client

ajouter la méthode lesLignes() qui retourne une liste de Ligne dans l’interface

source de l’interface

Implémenter la méthode dans la classe d’implémentation

Source de la classe d’implementation

92
Dans le client afficher la somme totale des objets retournées

Source de la classe Client

Capture du client

9- Accès aux donner

- Création de la base de données

Source de création de la base de données

Source de bd_lignes

o Créer la base de données bd_rmi

 Créer la table tb_ligne(id :entier, designation :chaine, prixUnitaire :
réel, quantite : entier)
 Ajouter la contrainte de clé primaire

Commande sql de la table tb_ligne

Source de bd_lignes

- Ajouter le package [Link]

o Ajouter la classe de Connexion

Source de [Link]

Source de [Link]

o Ajouter la classe LigneHelper

 Implementer la methode add (Ligne) qui permet d’inserer dans la
base de données une ligne de Ligne
 Implementer la methode getLignes() qui retourne une liste des lignes
de la table t_lignes

Source de [Link]

93
Source de LigneHelper

- Dans l’interface, ajouter les contrat add(ligne) et getLigne()

Source de l’interface

Source de l’interface TestRemote

- Dans la classe d’implémentation, implémenter les contrats

Source de la classe d’implémentation

Source de classe ImpRemote

- Déployer le service

Dans la classe clientes :

- Insérer une instance

- Afficher la liste des lignes

Source de Client

Source de client

Capture de la ligne

Coller ici la capture de Client

94