Programmation Java

1. Cours Tutoriel Java pour D´ebutant
Auteur : DIABY Kalilou
D´eveloppeur
E-mail : dika3584@gmail.com
1

2. dika
”Le bonheur c’est lorsque nos actes sont en conformit´es avec nos
pens´ees ”: Gandhi
2

3. Sommaire
Dans notre s´eance de tutoriel nous aborderons dans un premier temps les m´ethodes :
Outils de la Programmation Orient´ee Objet.
Puis des , l’h´eritage, le JAVABEAN, les exceptions, le design pattern , et par finir sur
un aper¸cu des JDBC.
NB : Nous aborderons pas le cote graphique de JAVA car d’un point de vue per-
sonnelles, je trouve qu’il existe des outils beaucoup plus puissants permettant de
d´evelopper de mani`ere graphique et de l’appeler dans un langage de programmation
tel que JAVA.
3

4. Part I
G´en´eralit´es
1 Rappels sur le monde de JAVA
1.1 Historique : Source : Wikipedia
Le langage Java est un langage de programmation informatique orient´e objet
cr´e´e par James Gosling et Patrick Naughton, employ´es de Sun Microsystems,
avec le soutien de Bill Joy (cofondateur de Sun Microsystems en 1982), pr´esent´e
officiellement le 23 mai 1995 au SunWorld.
La soci´et´e Sun a ´et´e ensuite rachet´ee en 2009 par la soci´et´e Oracle qui d´etient
et maintient d´esormais Java.
La particularit´e et l’objectif central de Java est que les logiciels ´ecrits dans ce
langage doivent ˆetre tr`es facilement portables sur plusieurs syst`emes d’exploitation
tels que UNIX, Windows, Mac OS ou GNU/Linux, avec peu ou pas de modi-
fications. Pour cela, divers plateformes et frameworks associ´es visent `a guider,
sinon garantir, cette portabilit´e des applications d´evelopp´ees en Java. Le lan-
gage Java reprend en grande partie la syntaxe du langage C++, tr`es utilis´ee par
les informaticiens. N´eanmoins, Java a ´et´e ´epur´e des concepts les plus subtils
du C++ et `a la fois les plus d´eroutants, tels que les pointeurs et r´ef´erences, ou
l’h´eritage multiple contourn´e par l’impl´ementation des interfaces. Les concep-
teurs ont privil´egi´e l’approche orient´ee objet de sorte qu’en Java, tout est objet
`a l’exception des types primitifs (nombres entiers, nombres `a virgule flottante,
etc.).
Java permet de d´evelopper des applications client-serveur. Cˆot´e client, les
applets sont `a l’origine de la notori´et´e du langage. C’est surtout cˆot´e serveur que
Java s’est impos´e dans le milieu de l’entreprise grˆace aux servlets, le pendant
serveur des applets, et plus r´ecemment les JSP (JavaServer Pages) qui peuvent
se substituer `a PHP, ASP et ASP.NET.
Java a donn´e naissance `a un syst`eme d’exploitation (JavaOS), `a des envi-
ronnements de d´eveloppement (eclipse/JDK), des machines virtuelles (MSJVM
(en), JRE) applicatives multiplate-forme (JVM), une d´eclinaison pour les p´eriph´eriques
mobiles/embarqu´es (J2ME), une biblioth`eque de conception d’interface graphique
(AWT/Swing), des applications lourdes (Jude, Oracle SQL Worksheet, etc.), des
technologies web (servlets, applets) et une d´eclinaison pour l’entreprise (J2EE).
La portabilit´e du bytecode Java est assur´ee par la machine virtuelle Java, et
´eventuellement par des biblioth`eques standard incluses dans un JRE. Cette ma-
chine virtuelle peut interpr´eter le bytecode ou le compiler `a la vol´ee en langage
machine. La portabilit´e est d´ependante de la qualit´e de portage des JVM sur
chaque OS.
1.2 Recommandations
Salut `a tous et `a toutes.
Ce cours se pr´esentera sous forme de tutoriels et sera `a vrai dire diff´erents de ceux que
vous aviez l’habitude de voir.
On partira d’un principe tr`es simple : Toujours donner le meilleur de soi mˆeme et ne
4

5. jamais au grand jamais donner son maximum
Ce tutoriel se pr´esentera sous la forme de petits exemples qui seront expliqu´es de fa¸con
simples en vue de faciliter sa compr´ehension. L’objet d’un tel document fut motiv´e
par deux facteurs que sont:
- la d´emystification de certains aspects de la programmation que l’on rencontre dans
bon nombre de documents de programmations.
- la mise `a la disposition de documents assez simple de compr´ehension et de lecture
de tous.
- l’´elaboration et ´ecriture de programmes intelligents, simple et propre.
- l’ utilit´e de tel ou tel langage de programmation.
5

6. Part II
Premiers pas
2 Introduction
En POO (Programmation Oriente Objet), JAVA, tout est classe et objet. Dans notre
sch´ema, nous ob´eirons la norme JAVABEAN, et ceux d`es le d´ebut de ce tutoriel. Il
nous est possible de d´evelopper de mani`ere traditionnelle ou d’utiliser un IDE. Nous
opterons ici pour l’ EDI (Environnement de D´eveloppement Int´egr´e) ; peut importe
celui que vous utiliser : ECLIPSE, INTELLIJI, NETBEANS.
´Ecrivons notre premier projet JAVA ( ctrl + n ), et donnons un nom a notre projet ;
dans mon cas je travaille avec JDK 7 .
Une fois cela fait cr´eons notre 1 `ere classe JAVA : dika.java
Au moment de la cr´eation de dika.java, il nous est demande de renseigner un nom
de Package que nous remplirons selon la convention du Reverse DNS pour Nom de
domaine Invers´e. Pour ceux qui ne le savent pas, le DNS est le nom que l’on attribue
`a une adresse IP(192.168.15.42) en vue de faciliter son acc`es que ce soit par le client
que par l’Informaticien. Cette @ IP fictive correspond a www.google.ci.
A supposer que l’on d´eveloppe pour ces derniers, on pourrait entrer comme nom de
package : ci.google.vuegenerale.
Ou dans le cas, ou l’on aura `a utiliser plusieurs packages : ci.google.vuegenerale.machine.control
Vue qu’ici on aborde JAVA de fa¸con simple, nous n’allons pas trop pol´emiquer sur ce
que c’est le package.
Ensuite cr´eons notre classe en y ajoutant un nom `a la classe.
Exemple :
Ajoutons un message de bienvenue dans notre console qui se trouve `a cˆote de l’onglet
probl`emes Pour ce faire, nous rajouterons ce bout de code :
System.out.println(”Bienvenue”);ou System.out.print(”Bienvenue”); .On obtient donc
6

7. :
package com.dikait.vuegenerale;
public class dika {
public static void main(String[ ] args) {
System.out.println(”Bienvenue”);
} }
Le System.out.print(”Bienvenue”) se contentera d’afficher le mot Bienvenue sans re-
tour `a la ligne. Alors que le System.out.println(”Bienvenue”); ferait automatiquement
un retour `a la ligne. Vous pouviez le tester en rajoutant d’autres choses dans votre
code.
7

8. Part III
Outils de la POO en JAVA
3 Les types Objets et primitifs
3.1 Les types primitifs
En POO, on emploie g´en´eralement le terme type primitif que lorsque veut fait
r´ef´erence `a des variables de types simples c’est `a dire pr´ed´efinie dans le langage en
question.
Il est d’usage de mettre la premi`ere lettre du nom de notre attribut( variable ) en
minuscules, puis le compl´eter ”comme nous le voulons”.
En JAVA, il en existe un bon nombre. Ce qui est le cas des autres langages de pro-
grammation orientes objets.
N´eanmoins certaines diff´erences s’y glissent d’un langage `a un autre.
Exemple : En Java le type String est un type primitif, alors qu’en CSharp (C#) ce
type est `a la fois Objet et/ou primitif selon l’´ecriture que l’on emploie; en l’´ecrivant
avec un grand ”S” il est un type Objet, et en l’´ecrivant avec un ”s” il devient un type
primitif.
Pour rester dans le cadre de JAVA, nous parlerons des types primitifs les plus utilis´es
que sont:
- Integer (Entier): Ce type permet de g´erer des attributs qui serviront au programmeur
de manipuler les entiers.
- Double (double): Ce type permet de g´erer des attributs qui prendront des valeurs
decimal avec une plage bien d´efinie( nombre de z´eros connue).
- Float (R´eel ): Ce type permet la manipulation de valeurs r´eel. Vous remarque sans
doute qu’il a les mˆemes fonctions que le double, alors quelle diff´erences existent-ils
entre ces deux types.
La r´eponse `a cette question serait en terme d’espaces de m´emoire qu’elle offre aux
attributs qui sont d´eclares en ce type; la plage est bien plus importante que celle du
double.
- Char (caract`ere): Celui ci permet la gestion des caract`eres(Exemple : a, est un car-
act`ere).
- String (Chaˆıne de caract`eres) : Comme son nom l’indique permet la gestion de
chaˆınes de caract`eres(mot bien faites ou pas). Retenez que ce sont des attributs qui
vous serviront dans votre programme vous pourriez choisir les noms qui vous sien.
3.2 Les types Objets
Lorsque l’on parle de type Objet, en fait l’on fait r´ef´erence a un mod`ele qui nous
est propre; c’est `a dire que ce type a ´et´e cr´eer par nous mˆeme. Ce type poss`ede des
comportements qui ont ´et´e d´efinies par le programmeur lui mˆeme. Pour ce qui est de
l’exemple voir la partie sur les classes. Exemple : Personne dika = new Personne();
4 Quelques mots clef
8

9. 4.1 this
Le mot clef this, est l’un des termes le plus utilise en POO. Car il permet au
programmeur de sp´ecifier `a son code qu’il souhaiterait effectuer une tache ou
un traitement sur l’objet en cours; il permet donc l’instanciation de l’objet en
cours.
Sa syntaxe est : this.objet;
Il s’utilise tr`es souvent `a l’int´erieur de m´ethodes pr´ed´efinies par le langage ou
d´efinie par le programmeur (l’ utilisateur).
NB : Ne perdez pas de vue le fait qu’en JAVA tout est classe et Objet.
4.2 super
En POO, nous sommes le plus souvent confrontes a des probl`emes de red´efinition
de m´ethodes. Ce qui a tendance `a souvent porter a confusion bon nombre de
programmeurs.
Pour palier `a ce probl`eme Java a mis `a la disposition des programmeurs,le mot
clef super afin que tout programmeur qui souhaiterait manipuler des m´ethodes
red´efinies de la classe m`ere dans la classe fille, puisse le faire.
Sa syntaxe est la suivante : super.methodeDeLaClasseMereRedefinie();
4.3 null
En POO, le vide est symbolise par le terme null et non par un espace blanc(champ
vide).
Parlant du vide qu’entendons-nous?
Par vide, nous exprimons le fait pour un objet, son existence ou pas. Partant
de l’exemple de certaines chemises, il est possible de s’apercevoir que certaines
d’entre elles n’ont pas de poches. On pourrait dans ce cas en JAVA, parler de
poche == null .
5 Les m´ethodes en POO JAVA
5.1 M´ethode de classe
Une m´ethode peut-ˆetre d´efini comme une fonction, qui sera utilisable dans tout le
programme. Elle poss`ede un type de retour(primitif ou objet) , une port´ee, un ou des
arguments, et le mot cl´e static. Elle permet une organisation plus simple et efficace
des objets que nous auront `a utiliser. Exemple de m´ethode de classe :
Type de retour: void (rien)
Port´ee : Public
Le nom de la m´ethode ici correspond a methode-de-classe
Nombre d’arguments : aucun
5.2 M´ethode Objets
M´ethodes d’objets quand `a eux n’ont pas le mot cl´e static. Nous verrons plus en d´etail
cela lorsque nous verrons les getters et setters.
Port´ee Public : Accessible `a toutes les classes du package.
9

10. private: Accessible qu’aux m´ethodes de la classe dans laquelle elle est contenue.
protected : Accessible au mˆeme package.
5.3 Red´efinition
La red´efinition consiste `a r´e´ecrire une m´ethode d´ej`a existante de notre classe
m`ere, dans notre classe h´eriti`ere ( fille ). De ce fait si l’on h´erite de la m´ethode
JavaBean(String nom, String prenom), on pourrait red´efinir cette m´ethode en
la modifiant en gardant ces arguments, port´ee, ...
Exemple : Redefinition.java
- JavaBean.java
import java.util.Set;
public class JavaBean {
String nom, prenom;
public JavaBean() { ... }
public String getNom() {
return nom; }
public String getPrenom() {
return prenom; }
public void setNom(String nom) {
this.nom = nom; }
public void setPrenom(String prenom) {
this.prenom = prenom; }
10

11. public void JavaBeanMethodeARedefinir(String nom, String prenom) {
System.out.println(”Je suis la mehode JavaBeanMethodeARedefinir de la classe
m`ere”); }
}
- Redefinition.java
public class Redefinition extends JavaBean {
public void JavaBeanMethodeARedefinir(String nom, String prenom) {
super.JavaBeanMethodeARedefinir(nom, prenom);
// Le mot super permet de faire r´ef´erence `a la classe m`ere
System.out.println(”Je suis la mehode JavaBeanMethodeARedefinir de la classe
fille”);}
public static void main(String[ ] args) {
Redefinition objet = new Redefinition();
objet.JavaBeanMethodeARedefinir(””, ””); }
}
5.4 Surcharge
La surcharge ou sur-d´efinition consiste pour une m´ethode d’ˆetre r´e´ecrite avec
des arguments diff´erents.
Par exemple dans la premi`ere, on peut avoir un argument, dans la deuxi`eme
deux argument,et ainsi de suite, ... , et toujours en gardant la mˆeme signa-
ture(type de retour, port´ee, nom de la m´ethode).
Exemple : Sucharge.java
class Test {
public void personne(String nom) {
// la m´ethode prend un argument
System.out.println(”Je prends un seul argument qui est : ” + nom); }
public void personne(String nom, String prenom) {
// la m´ethode prend deux arguments
System.out.println(”Je prends deux arguments qui sont : ” + nom + ” ” +
prenom); }
}
public class Surchage {
public static void main(String[ ] args) {
Test objet = new Test();
// cr´eation d’un nouvel objet
objet.personne(”DIABY”);
objet.personne(”DIABY”, ”Kalilou”); }
}
11

12. 6 Polymorphisme
Le polymorphisme est le fait de pouvoir red´efinir des m´ethodes h´erit´e de la
classe de base. C’est la possibilit´e de traiter de la mˆeme mani`ere des objets de
type diff´erents, pour peu qu’ils soient tous de classes d´eriv´ees de la mˆeme classe
m`ere.
Son but est d’am´eliorer l’extensibilit´e d’un programme.
7 Encapsulation
L’encapsulation est un terme qui signifie qu’il n’est pas possible d’agir di-
rectement sur les donn´ees. Pour ce faire, on utilise des m´ethodes qui jouent le
rˆole d’interfaces.
En JAVA, cela est r´ealis´e via les accesseurs et mutateurs se trouvant dans notre
bean.
8 Interaction utilisateur
8.1 G´en´eralit´es
Dans toute activit´e et vie humaine, la communication est une condition
n´ecessaire `a son bon fonctionnement et son maintient.
C’est s’inspirant de ce principe, que tout programme se doit d’ˆetre le plus inter-
actif que possible en donnant la main `a l’utilisateur de telle sorte a ´eviter qu’il
s’ennuie assez vite lorsqu’il sera amener `a utiliser votre application.
En POO, ou PP , cela se fait via des m´ethodes d´ej`a existantes dans des classes
fournies et d´eveloppeurs par les concepteurs de ce logiciel.
8.2 M´ethode de saisie utilisateur
8.2.1 Scanner
La m´ethode Scanner est une m´ethode permettant de donner la main a l’utilisateur.
Elle s’ insert dans notre code grˆace `a ce bout de code :
Scanner saisieUtilisateur = new Scanner(System.in);
/* System est une classe JAVA. Le ”.in” ou ”.out” permet d’utiliser respective-
ment l’entr´ee et la sortie du clavier .*/
On `a aussi besoin d’importer le package qui lui faut. Ici, le terme package corre-
spond `a une librairie. Car en important un package, on charge la librairie dans
lequel se trouve la m´ethode appelante.
Cela se fait grˆace `a cette instruction : import java.io.*;
// Le * permet d’importer tous les ´el´ements de cette librairie d’entr´ee et sortie.
Exemple : Interaction.java
import java.util.Scanner;
class Interaction{
public static void main String [ ] args){
12

13. private int valeur1;
Scanner lecture = new Scanner(System.in);
valeur1 = lecture.nextInt();
}}
8.2.2 Autres m´ethodes
Pour ce qui est des autres m´ethodes veuillez a vous r´ef´erer au web. Un tas de
documents s’y trouvent.
9 Outils de comparaisons
En programmation et dans la vie de tous les jours, l’on est amener a ef-
fectuer un ensemble de taches et d’op´erations. Cela se fait bien grˆace `a l’aide
d’une logique de raisonnement et d’op´erateurs math´ematiques que nous avions
eu l’habitude de traiter durant nos ´etudes primaires et secondaires, ou mˆeme
d’ailleurs dans notre vie quotidienne.
Prenons l’exemple de l’´ecole : Lorsque j’irais en classe j’utiliserais soit mon stylo
bleu ou mon stylo rouge pour ´ecrire et prendre note.
NB: Dans notre programmation, le terme Type sera utilise pour faire r´ef´erence
aux diff´erents types que nous connaissons que ce soit Objet ou primitifs.
9.1 L’´egalit´e ( ==) et l’ affectation (=)
En Programmation, le signe == et = diff`erent.
9.1.1 L’ affectation ( = )
L’affectation consiste `a donner une valeur `a un attribut bien sp´ecifique; elle
fixe la valeur de cette variable alpha `a une valeur bˆeta.
Sa syntaxe est : Type variable1 = variable2;
Toutefois, il nous est possible d’affecter une valeur `a plusieurs variables d’un
coup.
Sa syntaxe est : Type variable1, variable2 = variable3;
Exemple : Affectation.java
class Affectation
String nom = ”DIABY”;
// On affecte ici au nom le mot DIABY int numero, identifiant = 123;}
9.1.2 L’ ´egalit´e ( == )
L’´Egalit´e consiste `a tester si une valeur valeur1 correspond `a une valeur
valeur2. Elle s’utilise g´en´eralement avec les structure de contrˆoles.
Sa syntaxe est : if(valeur1 == valeur2){ //instruction }
Exemple : Egalite.java
class Egalite{
Type valeur1 = 12; Type valeur2 = 50;
13

14. if(valeur1 = valeur2){
System.out.print(”Valeur 1 est ´egale `a valeur 2”);}
... }
9.2 Le OU logique (||)
Le OU logique permet d’effectuer des test. Elle s’utilise tr`es souvent dans les
structures de contrˆole. Sa syntaxe est : if(varaiable1 == variable3 || variable2
== varaible4){ ... }
Prenons l’exemple de la tenue vestimentaire. Si elle est tremp´ee ou si elles et
sale, je ne la mettrai pas.
Exemple : OuLogique.java
class OuLogique{
if(tenue == trempee || tenue = sale){
System.out.print(” Je ne porterai cette tenue vestimentaire”);}
}
9.3 Le ET logique( && )
Le ET Logique tout comme le Ou Logique, permet d’effectuer des test. Et
elle s’emploie ´egalement dans les structures de contrˆole.
Sa syntaxe est : if (variable1 == variable3 && variable2 == variable4){ ... }
Prenons l’exemple des feux tricolores. Si le feu est rouge et qu’il n’y a pas de
voiture sur la voie alors je traverse la rue.
Exemple : EtLogique.java
class EtLogique{
if ( feux == rouge && voiture == null ){
System.out.print(”Je traverse la rue”);}
... }
9.4 Le modulo ( % )
Le modulo consiste en programmation, `a un traitement d’une variable sur une
autre variable en vue d’obtenir le reste de cette derni`ere. En d’autres terme,
il consiste `a obtenir le reste de la division de la variable1 par la variable2. Sa
syntaxe est: Type variable1, variable2, resultat;
resultat = variable1 % variable2;
Partons d’un exemple simple, pour celui ci. Nous chercherons a d´eterminer le
reste de la division de 5 par 2 (5 modulo 2).
Exemple : Modulo.java
class Modulo{
int valeur1 = 5;
int valeur2 = 2;
int reste;// Par d´efaut, un entier(int) est initialise `a zero (0)
reste = valeur1 % valeur2;
System.out.println(”Le modulo de 5 par 2 est ”+reste);}
14

15. }
10 Le JAVABEAN
La norme JAVABEAN est un des principes les puissants, lorsque l’on est
amener `a coder de mani`ere s´ecuris´e et propre.Elle consiste en cr´eer une classe
sp´eciale .java qui contiendra notre bean. Une classe JAVABEAN se pr´esente
comme suit :
- Tous les champs sont d´eclar´es de types priv´ees - Un constructeur par d´efaut
est initialis´e(est ajoute au code de notre classe javabean)
- Des accesseurs (getters) et mutateurs (setters) y sont ajoutes
- une S´erialisation des Objets peut ˆetre envisag´es
10.1 D´eclarations des attributs
Tout attribut(variables ou champs) doit ˆetre d´eclar´es de type priv´ees. Pourquoi
cela ?
Cela ne permettra la manipulation de ces dits attributs que par les accesseurs
et mutateurs commis `a chacune de ces variables.
Exemple : JavaBean.java
class JavaBean{
private String nom, prenom;
private int age;
private float taille;
}
10.2 Constructeurs
Un constructeur est une m´ethode qui porte le mˆeme nom que la classe, elle
ne comporte pas de param`etres,ni d’arguments, ni de type de retour, et `a une
port´ee de type public.
Il est `a noter que toute classe Java poss`ede un constructeur par d´efaut, et ceux
mˆeme s’il n’est pas ´ecrit dans notre code.
Un constructeur `a notre classe bean se doit d’ˆetre cr´ees.
Exemple : JavaBean.java
class JavaBean{
public JavaBean(){
// On d´efinit ici ce que fera le constructeur( les actions qu’il devra ex´ecuter). }
}
10.3 Accesseur
On utilise des m´ethodes get pour pouvoir manipuler les diff´erents attributs
d´eclar´es de type priv´es. Ces diff´erentes m´ethodes get ,appelle getters, permet-
15

16. tent une manipulation plus s´ecuris´e des diff´erentes valeurs.
Exemple : JavaBean.java
class JavaBean{
private String nom, prenom;
public String getNom(){
return nom;}
}
10.4 Mutateur
Idem comme pour le getters. Le mutateur est une m´ethode set permettant la
manipulation des attributs d´eclar´es de type prives et qui se trouve dans notre
classe java.
Exemple : JavaBean.java
class JavaBean{
private String nom, prenom;
public void setNom(String nom){
this.nom = nom; }
}
NB: Ce principe de programmation respectant la norme JAVABEAN permet
une meilleure s´ecurit´e et facilite la r´eutilisation des objets auxquels l’on `a affaire.
11 Classe
En POO, la notion de classe est un des ´el´ements les plus importants principe
qui lui conf`erent le titre de langage de POO et le diff´erencie des langages de
Programmation Proc´edurale.
Il est de mise de mettre en CAPITAL (ou en Majuscule) la premi`ere lettre de
chaque mot lorsqu’il s’agit de donner le nom d’une classe. Et par la suite tous
les nouveaux mots qui la composent, la premi`ere lettre en CAPITALE.
En JAVA, il existe des plusieurs types de classes. Toutefois, au sein d’un projet
(ou application) plusieurs classes peuvent exister mais une seule classe main
existe et est lanc´ee `a l’ex´ecution de notre projet. une classe se d´eclare comme
suit:
class NomDeLaClasse{
}
11.1 Classe Principale
Une classe principale est une classe qui permet l’ex´ecution de notre applica-
tion et elle est unique. Elle se d´eclare comme suit :
Exemple :
16

17. class ClassePrincicipale{
/* Les deux lignes qui suivent permettent de dire `a notre EDI qu’il s’agit de
notre classe principale. */
public static void main(String [ ] args){
// Instruction de notre main }
}
11.2 Classe Simple( Non principale )
Une classe est par d´efinition, un ensemble dans lequel se trouve les infor-
mations sp´ecifique `a notre traitement en POO. Elle se dit simple, si elle ne
comporte pas de main.
NB: Toutefois, attention `a ne pas g´en´eraliser trop vite.
Sa forme g´en´erale est : class NomDeLaClasse{ ... }
Prenons comme exemple, une classe contenant en son sein un attribut et une
m´ethode. Exemple : Simple.java
class Simple{
private String nom =”DIABY”;
public void affiche(){
System.out.print(”Salut”);}
}
11.3 Classe Abstraites
Sachez tout simplement qu’elles existent.
Nous n’en parlerons pas dans ce tutoriel.
12 Structures de contrˆoles : boucles
Les structures de contrˆoles r´epondent `a une certaine logique auquel nous
sommes confrontes tous les jours de notre vie. Cette logique, se trouve rapi-
dement retranscrit dans le code. Vue ce fait, et aussi pour ne pas avoir vous
embrouille on fera des exemples tr`es terrains c’est `a dire de la vie courante.
Son principe est de faire un certain contrˆole puis d’en v´erifier sa v´eracit´e puis
en fonction de la r´eponse obtenue d´eclenche une action(un ´ev´enement).
12.1 IF
IF (ou Si ), est une structure de contrˆole `a laquelle nous sommes confrontes
`a tout instant de notre vie. Cette structure de contrˆole `a pour but de tester
qu’une seule fois l’instruction qui lui est soumise.
Elle est de la forme : if (// argument) { ... } else { ... }
Partons d’un exemple : S’il fait jour ou qu’il est 7 h 30 min, je bois du caf´e,
sinon s’il est midi je mange du riz sinon s’il est 16 h je prendrais un goˆuter,
sinon s’il fait soir je mangerais du l´eger, sinon(dans le cas ou aucune de ces 3
condition ne parvient `a ˆetre r´ealis´e ) je me contenterais d’un verre d’eau.
17

18. Exemple : StructureContole.java
class StructureControle{
public static void main(String[ ] args) {
String heure = ”jour”;
// Vous pouvez vous amusez `a changez la valeur de l’heure. Remarquez,
// il est de type String
if (heure == ”jour”) {
System.out.print(”Je bois du caf´e au lait”);
} else if (heure == ”midi”) {
System.out.print(”Je mangerai du riz”);
} else if (heure == ”soir”) {
System.out.print(”Je mangerai du l´eger”);
} else {
System.out.print(”Je bois de l’eau”);
}
}
12.2 FOR
For ( pour en fran¸cais), quand a elle s’utilise dans le cas d’ it´erations (suite
d’´ev´enements). Cette structure de contrˆole `a pour but de tester l’instruction
qui lui est soumise d’une valeur alpha(point de d´epart) `a une autre valeur
bˆeta(valeur d’arrˆet).
Elle est de la forme : for (int alpha, alpha < bˆeta; alpha ++) { ... }
Prenons l’exemple des bonbons.
Pour toute personne dont l’age est inf´erieure `a 18, on lui donne un bonbon.
Exemple : StructureControle.java
public class StructureControle {
public static void main(String[ ] args) {
for (int agePersonne = 0; agePersonne < 18; agePersonne++) {
System.out.print(”Vous aurez droit `a un bonbon”); }
}
}
12.3 DO WHILE
WHILE( tant que), pourrait ˆetre d´efinit comme s’utilisant pour v´erifier un
´etat bien sp´ecifique , devant ˆetre rempli. Sa syntaxe : while(//argument){...}
DO WHILE, `a un comportement quasi similaire `a celui du while ; seul diff´erence,
l’instruction sera ex´ecut´e au moins une fois. Sa syntaxe : do { ... } while(//argument)
{ ... }
Cette structure de contrˆole, do while, `a pour but de lancer(ou d’ex´ecuter)
l’instruction se trouvant dans le do, puis de tester celle se trouvant dans le
while.
Exemple : Tant que l’age de l’utilisateur est inf´erieur a 18 dites lui qu’il n’a
18

19. pas acc`es `a ce service. Faire Salut , et apr`es on entre dans le while en v´erifiant
que l’utilisateur est ˆages d’au moins 18 ans et on lui donnera acc`es dans le cas
contraire on lui dira qu’il n’a pas acc`es a ce service.
Exemple : StructureControle.java
import java.util.Scanner;
public class StructureControle {
public static void main(String[ ] args) {
Scanner lecture = new Scanner(System.in);
int age;
do {
System.out.println(”Salut, veuillez saisir votre ˆage”);
age = lecture.nextInt(); }
while (age >= 18);
System.out.print(”Vous n’aviez pas acc`es `a ce service”); }
}
12.4 SWITCH
Switch est la structure de contrˆole que j’adore car pour moi elle s’utilise dans
les situations ou nous connaissions les cas de figures qui peuvent se pr´esenter `a
l’avance. Elle devient plus pr´ecise, donc ´evite l’utilisation du IF qui se trouve
ˆetre trop englobant (g´en´eraliste). Sa forme est :
switch (//valeur ) {
case value: //...
break;
default://...
break;}
Utilisons ici, le cas d’un programme qui demande `a un utilisateur de faire un
choix entre diff´erentes cat´egories d’ages (mineur, adulte, vieillard) en fonction
de son age et nous lui retournerons un message lui donnons sa cat´egorie d’ˆage.
Exemple : StructureControle.java
import java.util.Scanner;
public class PPrincipale {
public static void main(String[] args) {
Scanner lecture = new Scanner(System.in);
int age;
System.out.println(”Veuillez faire votre choix : 1 pour mineur , 2 pour adulte,
3 pour vieillard”);
age = lecture.nextInt();
switch (age) {
case 1: System.out.print(”Vous ˆetes un mineur”); break;
case 2: System.out.print(”Vous ˆetes un adulte”); break;
case 3: System.out.print(”Vous ˆetes un vieillard”); break;
default: System.out.print(”Vous ˆetes inconnu dans notre base”);
break; }
}
19

20. }
13 Tableau
13.1 G´en´eralit´es
Un tableau est un moyen de regrouper des ´el´ements dans un seul objet, puis de
permettre d’effectuer des traitements sur ce dernier que sont la lecture, ´ecriture,
ex´ecution d’op´erations.
En Programmation, le tableau s’utilise dans le gain d’espace m´emoire, car toute
conception d’ application se veut la plus ´economique possible en termes de
m´emoires utilises.
13.2 JAVA
En JAVA, il s’utilise pour stocker des donnes sur un individus bien sp´ecifique.
Prenons un individus qui est une personne, on pourrait avoir sur lui son nom,
prenom, age, sexe; que nous stockerons dans un tableau de type String.
13.2.1 Tableau Primaire
Par tableau primaire, j’entends tableau de type primitifs. On distingue plusieurs
types dont les tableau `a une dimension et les tableaux `a deux dimensions.
13.2.2 Tableau `a une dimension
Le tableau `a une dimension est un type de tableau ne pouvant prendre qu’une
valeur par zone de m´emoire.
Sa syntaxe est :
Pour cr´eer un tableau d’entier : int tableau [] = {””,”””,... }
Pour r´ecup´erer un ´el´ement de ce tableau : tableau[0]
NB : En java et dans la plupart des langages de programmations, on commence
par compter `a partir de zero (0). Faisant de 0 le premier ´el´ement.
Reprenons l’exemple pr´ec´edent portant sur la personne poss´edant un nom, ...
Exemple : TableauPrimaire.java
public class TableauPrimaire {
public static void main(String[ ] args) {
String[ ] personne = { ”DIABY”, ”Kalilou”, ”21”, ”Masculin” };
System.out.print(personne[0] + ” ” + personne[1] + ” ” + personne[2] + ” ans
et de sexe ” + personne[3]);}
}
13.2.3 Tableau `a plusieurs dimensions
Le tableau `a plusieurs dimensions fonctionnent de la mˆeme mani`ere que celui
`a une dimension `a la seule diff´erence qu’il prend plus d’un ´el´ement sur une zone
20

21. m´emoire.
Partant de l’exemple pr´ec´edant si l’on ´etait amener `a identifier la personne se
trouvant a une position donn´ee : cas d’une salle de classe ou autre salle bien
dispos´ee. l’on serait amener `a cr´eer un deuxi`eme tableau; ce qui serait trop long
et fatiguant.
Pour y rem´edier l’on `a disposition le tableau `a plusieurs dimensions.Et dans ce
cas pr´ecis, on peut cr´eer un tableau a 2 dimensions et qui aura en une seule
zone tous les ´el´ements relatifs `a la position d’une personne.
Exemple : TableauDeuxDimensions.java
public class TableauDeuxDimensions {
public static void main(String[ ] args) {
String[ ][ ] personnes = { { ”DIABY Kalilou”, ”Kone Paterson”, ”GOHORE
BI Arsene”, ”IBO Landry” }, { ”KOUAME Dimitry”, ”AMICHIA Affiba”, ”
FOLLY Vomua”, ”N’CHO Lo¨ıc ” } };
System.out.print(personnes[0][0]);}
/* Ici il affichera la personne la ligne 0 (ligne 1) et la colonne 0 ( colonne
0), qui se trouve ˆetre DIABY Kalilou */
// Toutefois, amusez-vous a changer les diff´erentes valeurs
}
13.2.4 Tableau de type ArrayList
Une ArrayList est un tableau list´es pour stocker et contenir un ensemble
d’´el´ements sous forme de liste.
Sa syntaxe est : ArrayList<Type Objet> nomArrayList = new ArrayList<Type
Objet>
Exemple : ArrayList1.java
import java.util.ArrayList;
public class ArrayList1 {
public static void main(String[ ] args) {
ArrayList <String> list = new ArrayList<String>();
list.add(”DIABY”); // on ins`ere un nom `a l’index 0
list.add(”Kalilou”);
list.add(2, ”Masculin”);
/* Ici, le 2 est mis pour l’index; le forcant ainsi `a le mettre `a l’index 2. Sinon,
l’on aurait Kalilou qui aurait ete `a la position 1 s’il avait ete declaree comme
DIABY */
System.out.print(”L’enregistrement se trouvant `a la position 0 est ” + list.get(0)
+ ” et a la position 1 est : ” + list.get(1) + ” et a la position 2 est : ” +
list.get(2)); }
}
21

22. 22

23. Part IV
Exception
14 Exception Pr´ed´efinies
En POO, ou en Programmation Proc´edurale (PP), la gestion des erreurs
est un crit`ere n´ecessaire de bon codage. Par ce principe, l’on est capable
d’intercepter d’´eventuelles erreurs qui pourrait surgir pendant l’utilisation de
notre application par l’utilisateur ou des erreurs autres. Pour ce faire, on utilise
des instructions que sont : try, catch(), finally.
14.0.5 TRY
L’instruction try est celle qui nous permettra d’ex´ecuter notre bout de code
susceptible de g´en´er´e d’´eventuelles erreurs.
Exemples : Exception.java
class Exception{
public static void main(String [ ] args){
private int valeur1, valeur2;
private float resultat;
try{
resultat = valeur1 / valeur2;
}
}
14.0.6 CATCH
L’instruction Catch est celle charg´ee de g´erer l’erreur qui est g´en´erer par notre
application.Elle capte ce message et en renvoie un autre beaucoup plus simple
et facile de compr´ehension par le client.
Exemples : Exception.java
class Exception{
public static void main(String [] args){
private int valeur1, valeur2;
private float reultat;
try{
resultat = valeur1 / valeur2;
}
catch(Exception une exception arithmetique sera genere){
System.out.print(”Erreur !”);
23

24. }
} } }
14.0.7 FINALLY
L’instruction finally permet l’ex´ecution de la commande de mani`ere obligatoire,
c’est `a dire apr`es ex´ecution des du try et du catch.
Cette instruction s’utilise g´en´eralement avec une base de donn´ees (nous em-
ploierons dans la suite de ce tutoriel tr`es souvent le terme database en rem-
placement de base de donn´ees), afin de d´econnecter notre database, dans le cas
o`u elle ne r´eussit pas a ˆetre d´econnecte dans le try et le catch.
Exemple : Exception.java
class Exception {
public static void main(String [ ] args){
private int valeur1, valeur2;
private float reultat;
try{
resultat = valeur1 / valeur2;
}
catch(Exception une exception arithmetique sera genere ){
System.out.print(”Erreur !”);}
finally {
System.out.println(”Ex´ecution des instructions se trouvant dans le finally”);}
} }
15 Exception Personnalises
Une exception personnalise s’utilise g´en´eralement lorsque l’on souhaite g´en´erer
soit soit mˆeme ces exceptions ; il s’av`ere ˆetre nul lorsque l’exception que l’on
souhaite cr´eer existe d´ej`a. Pour ce faire, on utilise le mot cl´e throw et throws.
Pour ce faire, on cr´ee une nouvelle m´ethode dans laquelle on d´efinit nos diff´erentes
exceptions.
15.1 THROW
Le mot clef throw permet de g´erer manuellement une exception. Cela se fait
grˆace `a la cr´eation de nouvel objet du type de l’exception que nous venons de
cr´eer nous mˆeme.
Allez comprendre, que nous densifierons les diff´erentes erreurs possibles et ca-
pables de survenir, et aussi ce qu’il en devra r´esulter une fois que ce cas se
pr´esentera.
Sa syntaxe est : throw new Exception
Partons ici d’un exemple tout simple qui consistera `a nous afficher tout simple-
ment un message qu’est : Erreur ! exception personnalis´e.
24

25. Exemple : ExceptionPersonnalise.java
public class ExceptionPersonnalise extends Exception{
@Override public String getMessage() {
System.out.println(”Erreur ! exception personnalis´e ”);
return super.getMessage(); }
}
- PPrincipale1
.java
public class PPrincipale {
public static void main(String[] args) {
try {
throw new ExceptionPersonnalise();
} catch (Exception e) {
e.printStackTrace(); }
}
}
15.2 THROWS
Le mot clef throws permet d’indiquer `a notre JVM que cette m´ethode est
susceptible de d´eclencher une erreur. Sa syntaxe est :
Methode throws ClasseExceptionCreerParUtilisateur { ... }
1P pour programme
25

26. Part V
H´eritage
16 G´en´eralit´e
L’h´eritage est une technique de la POO qui permet `a une classe fille d’h´eriter
de tous les attributs et m´ethodes de la classe m`ere(de base). On utilise pour
cela le mot clef extends.
L’h´eritage permet de ce fait un gain en temps de travail et de calcul, et en
m´emoire puisque l’on aura qu’`a h´eriter d’une classe et automatiquement poss´eder
de toutes ses fonctionnalit´es.
De plus, on peut en rajouter de nouvelles que ce soit bien des m´ethodes au sein
de cette classe fille, ou les red´efinir ou les surcharger.
17 H´eritage selon JAVA
En JAVA, la question d’h´eritage peut s’´etendre jusqu’`a celle de l’impl´ementation.
De ce fait, une classe Java peut h´eriter d’une et unique classe Java, mais peut
toutefois impl´ementer plusieurs Interfaces.
Pour qu’une classe h´erite d’une autre classe on utilise le mot clef extends et
pour qu’elle puisse impl´ementer une interface on utilise le mot clef implements.
Exemple : Heritage.java
class Heritage extends JavaBean implements Interface1, ActionListener{
// instruction et code de notre classe Heritage
// Action Listener est un ´ecouteur d’action. Nous y reviendrons plus tard
}
26

27. Part VI
Design Pattern
18 G´en´eralit´es
Le design pattern est une architecture destine en g´en´erale vers des projets de
grande envergure. Toutefois, Il est applicable `a tout type de projet.
Le design pattern n’est pas une affaire de JAVA pour ne pas dire POO, elle
s’applique aussi aux langages du WEB tels que PHP, Ruby, ...
Dans notre tutoriel, nous parlerons du M-V-C. Cependant, il est `a noter qu’il
existe le M-V-C 2. Pour plus d’informations se r´ef´erer `a Internet.
19 M-V-C
Dans ce type d’architecture, la vue correspond `a l’ IHM:Interface Homme
Machine, pour le client (l’utilisateur final). Le contrˆoleur, tout en respectant
notre sch´ema, est notre classe beans qui est charge d’effectuer d’ ´eventuelles
modifications et actions sur nos diff´erents champs ; elle contrˆole le mod`ele.
Le mod`ele, ici repr´esente les diff´erentes classes a partir desquels le bean sera
utilise ; c’est `a dire la classe qui utilisera le bean afin d’acc´eder `a ses diff´erents
champs et m´ethodes
19.1 Mod`ele
Le mod`ele est en g´en´eral l’´el´ement qui permettra de d´efinir tous les objets
que nous auront `a manipuler dans notre application structure en M-V-C. C’est
en g´en´erale une classe en JAVA.
Comme additif, dans les applications Java Entreprise Edition (JEE), c’est notre
classe JAVABEAN.
19.2 Vue
La vue est et repr´esente notre Interface Homme Machine (IHM).
Pour ce qui est de JAVA, cette partie se g`ere grˆace au graphisme en utilisant
le JAVA SWING, AWT, qui se trouve aujourd’hui obsol`ete du fait que assez
de framework existe et permettent de cr´eer cette vue tout en se chargeant de
g´en´erer le code qui y va avec. Pour ce faire, on dispose d’outils tels que Netbeans,
JDeveloppers, ...
Dans le cadre d’une application web JEE, la vue peut ˆetre repr´esente par une
Java Server Pages (JSP).
NB : Une JSP est une page HTML capable de contenir du code JAVA.
19.3 Contrˆoleur
Le contrˆoleur est la classe a partir de laquelle tous nos traitements seront
effectues. Le contrˆoleur agit sur le mod`ele en avisant `a tout moment la vue,
permettant une gestion plus simple, s´ecuris´e et structure de notre programme.
27

28. Dans le cadre d’une application web JEE, elle repr´esente les servlet qui ef-
fectuerons les diff´erents traitements, tout en informant notre JSP.
NB : Une servlet est classe JAVA qui h´erite de classe HttpServlet, au travers de
laquelle existe des m´ethodes doPost et doGet permettant une interaction avec
la (ou les) JSP.
Exemple de Servlet
public class NewServlet extends HttpServlet {
protected void processRequest(HttpServletRequest request, HttpServletRe-
sponse response) throws ServletException, IOException {
}
@Override protected void doGet(HttpServletRequest request, HttpServle-
tResponse response) throws ServletException, IOException {
processRequest(request, response); }
@Override protected void doPost(HttpServletRequest request, HttpServle-
tResponse response) throws ServletException, IOException {
processRequest(request, response); }
@Override public String getServletInfo() {
return ”Short description”; }
}
19.4 M-V-C 2
Ce design pattern, M-V-C 2, ne poss`ede qu’une seule classe appelle Front
Control, qui va d´el´eguer certains traitements sp´ecifique `a d’autres classes, qu’on
appelle les classes de Command.
28

29. Part VII
Les Bases de donn´ees
20 G´en´eralit´e
De nos jours, toute bon application se doit de conserver l’historique des taches
effectues par l’utilisateur. Ceux ci, dans le but de lui offrir un certain confort de
par son utilisation(soft2
) tout en lui donnant l’envie de se reconnecter `a votre
application.
Dans le but de palier `a ce probl`eme, l’on a recours `a une base de donn´ees qui
sert de stockage `a nos diff´erentes donn´ees que sont :
- Informations personnelles utilisateurs
- Informations et sauvegarde du log utilisateur et machine
- etc, ...
Cette base de donn´ee se g`ere grˆace `a ce que l’on nomme un Syst`eme Gestion de
Base de Donn´ee Relationnel (SGBD 3
). Il en existe aujourd’hui plusieurs types
dont le SGBDR (R pour Relationnel) qui nous int´eresse dans ce tutoriel.
Ce tutoriel n’´etant ax´e sur la base de donn´ee, nous nous limiterons `a ce qui `a
´et´e dit, et pour plus de complement r´ef´erer a internet de bons documents s’y
trouvent.
La connexion a une base de donnes est devenue aujourd’hui, une tache que peut
effectuer tout programmeur. Cette connexion se trouve simplifie de nos jours,
vue la multitude de langages de programmations et de SGBD dont nous dis-
posons.
21 Java Database Connectivity
La connexion `a une base de donn´ees en JAVA, ce fait via un certain nombre
d’outils que sont un driver 4
, de m´ethodes de pr´eparations `a la connexion, de
quelques requˆetes SQL ou NOSQL.
21.1 T´el´echargements et installation du driver
Pour ce faire, il nous faut utiliser un driver. Comment y proc`ede-t-on?
21.1.1 T´el´echargements
Pour le t´el´echargement du driver, il est `a noter que bon nombre de SGBD
nous est offert. Toutefois, pas de panique, car le choix du SGBD est fonction de
2Logiciel
3Un logiciel de Gestion de Base de Donn´ees
4Un pilote qui `a pour but de permettre l’acc`es d’un ou des services `a un un autre service
qui l’installe.
29

30. l’utilisation de notre base de donn´ees, du public cible vers qui elle est orient´ee
et aussi de nos moyens.
Pour notre tutoriel, nous utiliserons MySQL. Sans tarder, t´el´echargeons le pilote
n´ecessaire `a cela en vue d’effectuer la connexion.
Dans notre cas, le driver `a chercher est: mysql-connector-java5
Lien de t´el´echargements :
Personnellement, moi j’ai le mysql-connector-java-5.1.32
NB : Je vous conseillerai de vous r´ef´erer `a Google en vue de trouver la version
la plus r´ecente de votre driver
21.1.2 Installation driver : MySQL
Pour l’installation, sachez tout simplement une chose; ce n’en est pas une.
Car, il nous suffit juste de charger la librairie de ce driver dans notre EDI6
et
l’int´egrer `a notre projet. Cela je pense que vous serez `a mesure de le faire.
21.2 M´ethodes de connexions `a une base de donnes
Nous voici enfin arrive `a l’instant de v´erit´e, celle de la connexion et des traite-
ments (requˆetes) a effectuer.
Avant tout sachez que tous les traitements que nous ferons ne seront possible
que par la librairie java.sql.*; qui se trouve inclus dans JAVA.
21.2.1 Etablissement de la connexion
Cr´eons `a pr´esent un nouvel objet pour la connexion `a notre base de donn´ees.
Pour cela, nous utiliserons l’objet Connection.
La syntaxe serait : Connection ObjetDeConnection;
21.2.2 Erreur `a ne jamais commettre avec les base de donn´ees
Dans bon nombre de cas, les bases de donnes servent `a stocker les informations
sensibles sur des personnes (morales et physiques). D’un tel point de vue, il est
d´econseill´e de laisser une connexion `a la base donnes ouverte trop longtemps
afin de r´eduire le hacking7
de nos data.
Pour cela, nous aurons recours au try, catch et finally8
.
Dans ce cas, il n’y aura pas d’exemple pr´ecis car d’un point de vue personnelle
le JDBC s’utilise beaucoup avec le JEE9
, et ceux mˆeme s’il existe dans les JSE10
.
5Je l’ai fait expr`es d’enlever la version afin que vous puissiez r´ecup´erez la derni`ere version
du driver souhait´ee
6Integrate Developement Environnement
7Piratage de nos donn´ees
8Vous comprendrez `a ce niveau l’importance de ce finally
9Java Entreprise Edition
10Java Standard Edition
30

31. 21.2.3 M´ethodes de connexions
La connexion s’´etablit grˆace a la m´ethode Class.forName() du moins si l’on
se base sur la norme 1.0 du JDBC.
31

32. Contents
I G´en´eralit´es 4
1 Rappels sur le monde de JAVA 4
1.1 Historique : Source : Wikipedia . . . . . . . . . . . . . . . . . . 4
1.2 Recommandations . . . . . . . . . . . . . . . . . . . . . . . . . . 4
II Premiers pas 6
2 Introduction 6
III Outils de la POO en JAVA 8
3 Les types Objets et primitifs 8
3.1 Les types primitifs . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.2 Les types Objets . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4 Quelques mots clef 8
4.1 this . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4.2 super . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4.3 null . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
5 Les m´ethodes en POO JAVA 9
5.1 M´ethode de classe . . . . . . . . . . . . . . . . . . . . . . . . . . 9
5.2 M´ethode Objets . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
5.3 Red´efinition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
5.4 Surcharge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
6 Polymorphisme 12
7 Encapsulation 12
8 Interaction utilisateur 12
8.1 G´en´eralit´es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
8.2 M´ethode de saisie utilisateur . . . . . . . . . . . . . . . . . . . . 12
8.2.1 Scanner . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
8.2.2 Autres m´ethodes . . . . . . . . . . . . . . . . . . . . . . . 13
9 Outils de comparaisons 13
9.1 L’´egalit´e ( ==) et l’ affectation (=) . . . . . . . . . . . . . . . . 13
9.1.1 L’ affectation ( = ) . . . . . . . . . . . . . . . . . . . . . 13
9.1.2 L’ ´egalit´e ( == ) . . . . . . . . . . . . . . . . . . . . . . . 13
9.2 Le OU logique (||) . . . . . . . . . . . . . . . . . . . . . . . . . . 14
9.3 Le ET logique( && ) . . . . . . . . . . . . . . . . . . . . . . . . 14
9.4 Le modulo ( % ) . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
32

33. 10 Le JAVABEAN 15
10.1 D´eclarations des attributs . . . . . . . . . . . . . . . . . . . . . 15
10.2 Constructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
10.3 Accesseur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
10.4 Mutateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
11 Classe 16
11.1 Classe Principale . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
11.2 Classe Simple( Non principale ) . . . . . . . . . . . . . . . . . . 17
11.3 Classe Abstraites . . . . . . . . . . . . . . . . . . . . . . . . . . 17
12 Structures de contrˆoles : boucles 17
12.1 IF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
12.2 FOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
12.3 DO WHILE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
12.4 SWITCH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
13 Tableau 20
13.1 G´en´eralit´es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
13.2 JAVA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
13.2.1 Tableau Primaire . . . . . . . . . . . . . . . . . . . . . . 20
13.2.2 Tableau `a une dimension . . . . . . . . . . . . . . . . . . 20
13.2.3 Tableau `a plusieurs dimensions . . . . . . . . . . . . . . . 20
13.2.4 Tableau de type ArrayList . . . . . . . . . . . . . . . . . 21
IV Exception 23
14 Exception Pr´ed´efinies 23
14.0.5 TRY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
14.0.6 CATCH . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
14.0.7 FINALLY . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
15 Exception Personnalises 24
15.1 THROW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
15.2 THROWS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
V H´eritage 26
16 G´en´eralit´e 26
17 H´eritage selon JAVA 26
VI Design Pattern 27
18 G´en´eralit´es 27
33

34. 19 M-V-C 27
19.1 Mod`ele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
19.2 Vue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
19.3 Contrˆoleur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
19.4 M-V-C 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
VII Les Bases de donn´ees 29
20 G´en´eralit´e 29
21 Java Database Connectivity 29
21.1 T´el´echargements et installation du driver . . . . . . . . . . . . . 29
21.1.1 T´el´echargements . . . . . . . . . . . . . . . . . . . . . . . 29
21.1.2 Installation driver : MySQL . . . . . . . . . . . . . . . . 30
21.2 M´ethodes de connexions `a une base de donnes . . . . . . . . . . 30
21.2.1 Etablissement de la connexion . . . . . . . . . . . . . . . 30
21.2.2 Erreur `a ne jamais commettre avec les base de donn´ees . 30
21.2.3 M´ethodes de connexions . . . . . . . . . . . . . . . . . . 31
34