Java Les Wikis

Java
Java
Java - Caractristiques
Java dveloppement Kit
Java - Premier programme
Java - Types de donnes
Java - Variables
Java - Oprateurs
Java - Les Structures conditionnelles
Java - Les Structures fonctionnelles
Classes Java
Java - Mthodes
Java - Objets
Java - Constructeur
Java - Hritage
Java - Accessibilit
Java - Packages
Java - Exceptions
Java - JDBC
Histoire de Java
Java est un langage de programmation objet, dont la syntaxe ressemble au langage C++. Il a
t mis au point partir de 1990 par la firme Sun Microsystems et officiellement prsent en
1995. Le but de Java l'poque tait de constituer un langage de programmation pouvant tre
intgr dans les appareils lectromnagers, afin de pouvoir les contrler, de les rendre
interactifs, et surtout de permettre une communication entre les appareils. Ce programme de
dveloppement se situait dans un projet appel Green, visant crer une tlcommande
universelle (Star 7, prsente en 1992) comprenant un systme d'exploitation capable de grer
l'ensemble des appareils lectromnagers de la maison. Etant donn que le langage C++
comportait trop de difficults, James Gosling, un des acteurs du projet (considr dsormais
comme le pre de Java) dcida de crer un langage orient objet reprenant les caractristiques
principales du C++, en liminant ses points difficiles, et en le rendant moins encombrant et
plus portable (il devait pouvoir tre intgr dans n'importe quel appareil...). Ainsi, ce langage
fut baptis dans un premier temps Oak (Oak signifiant chne). Toutefois, puisque ce nom tait
dj utilis, il fut rebaptis Java en l'honneur de la boisson prfre des programmeurs, c'est-
-dire le caf, dont une partie de la production provient de l'le Java.
A la mme poque, le Web faisait son apparition, or Java possdait toutes les caractristiques
faisant de lui un langage appropri pour le Web :
1
Le rseau des rseaux rassemblant sur une mme structure des machines diffrentes, il
fallait un langage capable de fonctionner sur chacune d'entre-elles: Java tait conu
pour tre portable
Le web tait limit en bande passante: Java tait conu pour tre petit
Ainsi, en 1994, l'quipe dcida de mettre au point un navigateur (baptis HotJava) intgrant
Java et capable de faire fonctionner des applets (des petites applications fonctionnant dans un
navigateur). C'est ainsi que fin 1995 Java eut un terrible essor avec le soutien de Netscape, qui
ne tarda pas inclure Java dans son navigateur...
Comparaison de Java et de C++

Le langage Java a une syntaxe trs proche du langage C++ mais est beaucoup plus orient
programmation objet. Certaines caractristiques critiques du langage C++ (celles qui sont
l'origine des principales erreurs) n'ont donc pas t reprises. Cela comprend :
Les pointeurs
La surcharge d'oprateurs
L'hritage multiple (remplac par la notion d'interface)
En revanche :
La libration de mmoire est transparente pour l'utilisateur (grce un ramasse-

miettes)
La gestion des exceptions est beaucoup plus rigoureuse
Les chaines et les tableaux sont des objets faisant partie intgrante du langage
Toutefois Java est moins rapide que le langage C++, car il est interprt par une machine
virtuelle. Il perd donc en rapidit ce qu'il gagne en portabilit...
Les versions de Java

Le langage Java n'est pas fix dans le temps, il volue, des ajouts au langage sont
rgulirement proposs, et l'API standard s'enrichie continuellement passant de 200 classes
prs de 4000 entre la premire et la "dernire" version :
JDK 1.0 (1996) : C'est la premire version stable du langage, de ce fait la totalit des
navigateurs la supporte
JDK 1.1 (1997) : Elle apporte des amliorations syntaxiques ainsi que des progrs au
niveau de l'interface utilisateur AWT et de la gestion des exceptions.
J2SE 1.2 (1998) : La version "2" apporte des amliorations multimdias. Elle permet
par exemple l'utilisation d'interface utilisateur graphique avance avec Swing, ainsi
que la possibilit d'interagir avec elle par le moyen de glisser-dpos
J2SE 1.3 (2000) : L'amlioration multimdia se poursuit avec l'apparition de l'API
Java Sound.
2
J2SE 1.4 (2002) : Multimdia toujours, avec une bibliothque de gestion d'images.
J2SE 5.0 (2004) : Ajouts de nouvelles fonctionnalits au langage, comme les
annotations, les numrations, la boucle "for each", les nombre d'arguments variables
(vargs), ou la conversion automatique entre les types primitifs et leurs classes
enveloppes.
Java SE 6 (2006)
Java SE 7 (2011)
3
Java - Caractristiques du langage
Fichier source, compilation et machine virtuelle
Le fichier source d'un programme crit en Java est un simple fichier texte dont l'extension est
par convention .java. Ce fichier source doit tre non formatt, c'est--dire un fichier texte dans
sa plus simple expression, sans mise en forme particulire (pas de texte soulign, en italique,
ou autres). En revanche le langage Java supporte les caractres Unicode, on peut donc y
introduire des caractres spciaux, en particulier des lettres accentues.
Lorsque le programme est prt tre "essay", il s'agit de le compiler (le traduire en langage
machine) l'aide d'un compilateur. Toutefois, contrairement aux langages compils
traditionnels, pour lesquels le compilateur cre un fichier binaire directement excutable par
un processeur donn (c'est--dire un fichier binaire contenant des instructions spcifiques un
processeur), le code source Java est compil en un langage intermdiaire (appel pseudo-code
ou bytecode) faisant apparatre autant de fichiers avec l'extension .class que de classes
dveloppes dans le code source.
Cette caractristique est majeure, car c'est elle qui fait qu'un programme crit en Java est
portable, c'est--dire qu'il ne dpend pas d'une plate-forme donne. En ralit le code
intermdiaire n'est excutable sur aucune plate-forme sans la prsence d'une machine
virtuelle, un interprteur (la machine virtuelle est d'ailleurs parfois appele interprteur Java)
tournant sur une plate-forme donne, et capable d'interprter le code intermdiaire.
4
Ainsi, pour peu qu'une plate-forme (windows 95, Unix, Linux, Amiga, ...) possde une
machine virtuelle fonctionnant sous son systme, celle-ci est capable d'excuter n'importe
quelle application Java !
De cette faon, l'ensemble des navigateurs permettant d'utiliser des applets possdent une
machine virtuelle...
Typologie
La manire d'crire les choses en Java est importante. Le langage Java est par exemple
sensible la casse (en anglais case sensitive), entendez par l qu'un nom contenant des
majuscules est diffrenci du mme nom crit en minuscules. Ainsi, les spcifications du
langage Java prcisent que la fonction principale doit tre appele main() et non Main() ou
MAIN().
D'autre part, toute instruction se termine par un point-virgule.
Applications et Applets
Java permet de crer deux types de programmes :
Les applications: programmes tels qu'on les connat, c'est--dire s'excutant dans le systme
d'exploitation condition d'avoir install une machine virtuelle. Voici ce quoi ressemble
une application Java :
public class Nom_du_programme {

public static void main (String args[]){
5
System.out.println("Hello World");
}
}
Les applets (prononcez Applettes, et traduisez Appliquettes, le nom grotesque donn en

franais) : Il s'agit de petites applications destines fonctionner sur un navigateur. Ainsi une
applet a un champ d'action beaucoup plus rduit qu'une application pour des raisons de
scurit (une applet ne peut par exemple pas accder au systme sur lequel elle s'excute...).
Voici un exemple d'applet :
public class Nom_de_l_applet extends java.applet.Applet {

public void paint (Graphics g){
g.drawString("Hello World",20,40);
}
}
Ajout de commentaires
Lorsqu'un programme devient long et compliqu il peut tre intressant (il est mme
conseill) d'ajouter des lignes de commentaires dans le programme, c'est--dire des portions
du fichier source qui ont pour but d'expliquer le fonctionnement du programme sans que le
compilateur ne les prennent en compte (car il gnrerait une erreur).
Pour ce faire, il est possible d'utiliser des balises qui vont permettre de dlimiter les
explications afin que le compilateur les ignore et passe directement la suite du fichier.
Ces dlimiteurs sont /* et */. Un commentaire sera donc not de la faon suivante :
/* Voici un commentaire ! */
Il y a toutefois quelques rgles respecter :
Les commentaires peuvent tre placs n'importe o dans le fichier source

Les commentaires ne peuvent contenir le dlimiteur de fin de commentaire (*/)
Les commentaires ne peuvent tre imbriqus
Les commentaires peuvent tre crits sur plusieurs lignes
Les commentaires ne peuvent pas couper un mot du programme en deux
Le langage permet aussi de mettre toute la fin d'une ligne en commentaire en utilisant le
double slash (//). Tout ce qui se situe droite de ce symbole sera mis en commentaire.
// Voici un autre commentaire !
Enfin, un dernier type de commentaires permet de documenter une application, de telle faon
que le programme JavaDoc (fourni avec le JDK, Java Development Kit, le kit permettant de
compiler du Java), puisse crer des documents HTML partir de l'application afin de la
documenter. Ces commentaires, vus comme des commentaires normaux par Java, sont reprs
par les dlimiteurs /** et */.
6
Java - Introduction
Qu'est-ce que le Java Dveloppent Kit
Le Java Dveloppent Kit, communment appel JDK, est le kit de dveloppement de base que
propose gratuitement la socit Oracle. Le Kit de dveloppement comprend plusieurs outils,
parmi lesquels :
javac: le compilateur Java

java: un interprteur d'applications (machine virtuelle)
applet viewer: un interprteur d'applets
jdb: un dbogueur
javap: un dcompilateur, pour revenir du bytecode au code source
javadoc: un gnrateur de documentation
jar: l'diteur d'archives Java
O se procurer le JDK
Le JDK est disponible gratuitement en tlchargement sur le site de la socit Oracle
Il existe autant de version de JDK que de version de Java (versions majeures ou mineures) et
ce sur chacune des plateformes prises en charge (Unix, Solaris, Windows, ...).
Il est conseill de prendre la dernire version afin d'viter les ventuels bugs des versions
prcdentes.
Le compilateur
javac est un compilateur, c'est--dire qu'il transforme le code source en bytecode, un fichier
binaire intermdiaire interprtable par la machine virtuelle sur n'importe quelle plate-forme.
javac s'utilise avec la syntaxe suivante :
javac <options> <fichiers java>
Une vingtaine d'options sont disponibles, parmi elles :
-cp pour prciser l'emplacement des codes sources par exemple pour permettre l'utilisation
de JARs externes
-g permet d'inclure dans le pseudo-code des informations de dbogage afin de pouvoir
utiliser le dbogueur jdb
-source assure une compatibilit ascendante avec les anciennes JDK, on peut donc compiler
du code Java compatible avec les versions 1.0, 1.1 etc... et ce mme si l'on dispose la
dernire version de la JDK.
7
L'interprteur
L'interprteur java est la machine virtuelle permettant de lire le bytecode.
java nom_du_fichier
L'interprteur d'applets
appletviewer a pour but de pouvoir visualiser l'excution d'un applet (il est aussi possible de la
visualiser sur la plupart des navigateurs internet. Sa syntaxe est la suivante :
appletviewer nom_de_l_applet.class
Javadoc
JavaDoc est un utilitaire permettant de crer une documentation au format HTML partir de
vos programmes, grce aux commentaires commentaires /** */ prvus cet effet, et qui sont
incorporer dans le code.
L'diteur d'archives
Jar est un utilitaire permettant de compresser toutes les classes d'un mme projet dans une
archive (formellement, un fichier zip avec l'extension .jar) pour constituer une bibliothque de
classes que l'on peut ensuite importer comme bibliothque externe un autre projet (avec
l'option -cp). Il est aussi possible de crer une archive excutable, c'est dire dfinir une
classe principale dont la mthode main sera automatiquement excut, sans avoir ouvrir
l'archive.
8
Java - Premier programme
Voici deux exemples (un programme console, et une applet) permettant d'avoir un aperu de
ce quoi peut ressembler un programme Java. La section suivante prsentera les primitives du
langage Java, c'est--dire les briques lmentaires pouvant tre utilises dans une classe...
Premier programme avec Java

La premire chose faire est de crer un simple fichier texte (sans mise en forme) et de taper
les quelques lignes suivantes :
/** Votre premier programme Java */

class FirstApp {
public static void main (String[] args){
}
}
tant donn que l'on a donn le nom de FirstApp notre classe, il est essentiel de sauver ce
fichier sous le nom FirstApp.java (un autre nom provoquera une erreur lors de la
compilation). A l'aide de la JDK (ou d'un environnement de dveloppement intgr qu'il
l'utilise), compilez le programme en vous plaant. En ouvrant une invite de commande (un
terminal) et en utilisant la commande suivante :
javac FirstApp.java
Si tout se droule normalement, le compilateur devrait crer un fichier nomm FirstApp.class. dans
le cas contraire, vous avez soit une erreur dans votre programme (vrifiez la syntaxe) ou bien vous
avez mal install la JDK...
En supposant que la JDK ait t installe correctement et que la syntaxe de votre programme
est bonne, vous pouvez dsormais excuter votre programme grce la machine virtuelle
Java, en tapant la commande suivante :
java FirstApp
Il ne faut pas spcifier l'extension (.class) au risque d'obtenir

une erreur !
Pour passer des arguments lors de l'excution, il suffit de prciser
ces arguments aprs le nom du fichier :
java NomFichier arg1 arg2 ...
Si il y a plusieurs arguments, ceux-ci doivent tre spars par un

espace.
Le programme devrait en toute logique afficher le message "Hello World" l'cran. Cela est
bien peu, mais constitue un bon dbut pour analyser le programme. Voyons ligne par ligne
comment est constitu cette application :
9
La premire ligne
/** Votre premier programme Java */
C'est une ligne de commentaires permettant d'ajouter des remarques sur l'application, elle peut
galement tre utilise pour gnrer automatiquement de la documentation.
La seconde ligne
class FirstApp {
dfinit la classe principale de votre application grce au mot cl class. Le nom que vous donnez
cette classe reprsente le nom de votre programme, cela signifie qu'une application Java possde au
moins une classe, et que celle-ci possde un nom correspondant au nom du programme. Puisque
Java est sensible la casse, le nom que vous donnez au programme doit tre rigoureusement le
mme que celui que vous donnez au fichier portant l'extension .java
La seconde ligne se termine par une accolade ouvrante "{", correspondant au dbut d'un bloc, c'est-
-dire un ensemble de lignes de codes correspondant la classe et dlimit par deux accolades.
La troisime ligne
public static void main (String[] args){
dfinit la mthode principale de l'application, c'est--dire une procdure propre la classe est
excute lors de son appel. Le mot cl void prcdant la mthode main() indique le type de retour de
la fonction, c'est--dire le type de valeur que la mthode doit retourner. Dans le cas prsent, il s'agit
du type void (signifiant rien en anglais), donc la mthode ne doit retourner aucune valeur. Les
parenthses suivant le mot main permettent de dfinir les paramtres de la mthode, c'est--dire les
donnes qu'elle reoit en entre. Dans cette application (et dans toutes vos futures applications) le
paramtre est String args[], ce qui correspond un ensemble (tableau) de chanes de caractres.
Cela correspond en ralit aux paramtres que vous placez aprs la ligne javac FirstApp.class, si, par
exemple, vous voulez pouvoir prciser des options lors de l'excution de votre application. Vous
rencontrerez parfois l'criture String[] args, cette criture est juste elle aussi, voire plus logique...
(cela sera expliqu plus loin).
Enfin les mots cls public et static dfinissent les caractristiques de la mthode main(). Le mot cl
public dfinit les classes pouvant excuter la mthode main(), public signifie donc que toutes les
classes peuvent y avoir accs. Or, l'interprteur Java tant "considr comme une classe", il est
essentiel qu'il puisse y avoir accs afin de lancer l'application... Comme dans le cas de la classe
FirstApp, la ligne dclarant la mthode main() se termine par une accolade ouvrante indiquant un
bloc correspondant au corps de la mthode main()
La quatrime ligne
10
correspond au corps de la mthode main(). Il s'agit de l'appel de la mthode println(), possdant un
paramtre (une chane de caractres). Cette mthode permet d'afficher sur la sortie standard (ici,
l'cran) la chane de caractre qui lui est passe en paramtre, en lui ajoutant automatiquement un
caractre de retour la ligne (il existe aussi une mthode appele print(), n'ajoutant pas de retour
la ligne). Cette mthode est prcde de System.out., cela signifie qu'elle fait partie de l'objet out,
faisant lui-mme partie de la classe System. En ralit toutes les mthodes dpendent d'une classe,
chacune faisant parties d'une hirarchie structure de classes. Ainsi, la classe System fait partie du
package lang, qui fait lui mme partie du package java. Toutefois, il n'est pas ncessaire de prciser
java.lang.System.out, car le package java.lang est import par dfaut. De cette faon, la ligne
"System.out.println("Hello World");" est quivalente "java.lang.System.out.println("Hello World");".
*Une application Java est une classe munie d'une mthode

public static void main(String[] args)
Le nom du fichier Java correspond au nom de la classe (avec la mme casse, c'est--dire
orthographi de la mme faon aux majuscules prs)
Premire applet avec Java

Les applets sont diffrentes des applications dans la mesure o il s'agit de petites applications
graphiques destines s'excuter dans un navigateur internet. D'autre part, les applets ont un
champ d'action limit pour des raisons de scurit puisqu'elles s'excutent dans un
environnement distant. Elles ne peuvent donc pas accder toutes les ressources de
l'environnement distant.
Voici donc le code d'une applet toute simple :
import java.awt.Label;
public class FirstApplet extends java.applet.Applet {

public void init (){
add(new Label("Hello World"));
}
}
Le programme devrait en toute logique afficher le message "Hello World" l'cran sur le navigateur,
condition de crer le fichier HTML appropri "hbergeant" l'applet :
<HTML>
<BODY>
<APPLET code="FirstApplet.class" width="100" height="30" align="left">
Message s'affichant si l'applet n'est pas supporte par le navigateur
</APPLET>
</BODY>
</HTML>
Pour visualiser l'applet, il vous suffit donc d'enregistrer ce fichier avec l'extension .html ou .htm,
comme par exemple FirstApplet.html.
11
Pour l'excuter vous pouvez :
soit utiliser appletviewer, en vous plaant dans le rpertoire contenant l'applet et le fichier
HTML, et taper la commande :
appletviewer FirstApplet.html
soit utiliser votre navigateur en ouvrant le fichier HTML
Voyons ligne par ligne comment est constitu cette applet :
La premire ligne
import java.awt.Label;
indique au compilateur qu'il a besoin de la classe situe dans le package java.awt pour pouvoir tre
compil correctement. Les classes AWT, reprsente une bibliothque de mthodes graphiques
permettant d'afficher des lments graphiques sur le navigateur.
La seconde ligne
public class FirstApplet extends java.applet.Applet {
dfinit la classe principale de votre applet grce au mot cl class. Le nom que vous donnez cette
classe reprsente le nom de votre programme, cela signifie qu'une applet Java possde au moins une
classe, et que celle-ci possde un nom correspondant au nom du programme. Le nom que vous
donnez au programme doit,comme pour les applications, tre rigoureusement le mme que celui
que vous donnez au fichier portant l'extension .java
Le nom de la classe est prcde du mot cl public, permettant l'utilisation de cette classe par le
navigateur. Elle est aussi suivie de la mention extends java.applet.Applet, indiquant que la classe que
l'on dfinit hrite d'une classe existante appele Applet. Cette classe dfinit une mthode init() vide,
ce qui signifie que l'applet possde par dfaut une mthode init(), qui peut tre redfinie.
La seconde ligne se termine par une accolade ouvrante "{", correspondant au dbut d'un bloc, c'est-
-dire un ensemble de lignes de codes correspondant la classe et dlimit par deux accolades.
La troisime ligne
public void init (){
redfinit la mthode init() de l'applet. Celle-ci ne possde pas d'argument et ne retourne aucune
valeur (son type de retour est void). Par contre cette mthode doit obligatoirement tre dfinie en
tant que public pour pouvoir tre excute correctement.
La quatrime ligne
12
add(new Label("Hello World");
correspond au corps de la mthode init(). Il s'agit de l'appel de la mthode add(), possdant un

paramtre (objet de la classe java.awt.Label et permettant d'afficher la chane de caractre passe
en paramtre). La mthode add() fait en fait partie de la classe java.awt.Panel, qui est une classe
parente de java.applet.Applet. De cette faon, java.applet.Applet possde l'ensemble des mthodes
qui sont dfinies en son sein, ainsi que l'ensemble des mthodes dfinies dans les classes dont elle
hrite...
13
Java - Les types de donnes
Les types primitifs
Les enveloppeurs (Wrappers)
o Nombre entier (byte, short, int, long)
o Nombre virgule (float, double)
o Caractre (char)
o Chanes de caractres (String)
Conversion de type de donnes (casting)
Les types primitifs

Java est un langage orient objet, c'est--dire qu'il manipule des classes, ou plus exactement
des objets, qui sont des instances de ces classes. Les donnes manipules avec Java, et que
l'on utilise au travers de variables, sont donc types, le type d'un objet correspond la classe
qu'il instancie.
Toutefois il existe quelques types primitifs, permettant de manipuler directement les donnes
les plus courantes. Ces donnes sont notamment spcifies par une reprsentation en
mmoire, et donc un nombre d'octets prdfinis.
Voici un tableau rpertoriant les huit types primitifs du langage Java :
Type Signification Taille (en octets) Plage de valeurs acceptes

char Caractre Unicode 2 '\u0000' ? '\uffff' (0 65535)
byte Entier trs court 1 -128 ? +127
short Entier court 2 -32 768 ? +32 767
int Entier 4 -231?-2,147109 ? +231-1?2,147109
long Entier long 8 -263?-9,2231018 ? +263-1?9,2231018
float Nombre rel simple 4 2-149?1.410-45 ? 2128-2104?3.41038
double Nombre rel double 8 2-1074?4,910-324 ? 21024-2971?1,810308
boolean Valeur logique (boolen) 1 true (vrai), ou false (faux)
Les enveloppeurs (Wrappers)

Chacun des types primitifs peut tre "envelopp" dans un objet provenant d'une classe prvue
cet effet et appele Wrapper (mot anglais signifiant enveloppeur). Les enveloppeurs sont
donc des objets reprsentant un type primitif.
Avantages :
Les Wrapper peuvent tre utiliss comme n'importe quel objet, ils ont donc leurs propres
mthodes.
Inconvnients :
14
L'objet enveloppant utilise plus d'espace mmoire que le type primitif. Par exemple, un int
prends 4 octets en mmoire mais un Integer utilisera 32 octets sur une machine virtuelle en 64
bits (20 octets en 32 bits).
L'objet enveloppant est immuable, c'est dire qu'il ne peut pas tre modifi, toute modification
de sa valeur ncessite de crer un nouvel objet et de dtruire l'ancien, ce qui augmente le temps
de calcul.
Voici la liste des enveloppeurs de chaque type primitif Java :
Enveloppeur Type primitif

Character char
Byte byte
Short short
Integer int
Long long
Float float
Double double
Boolean boolean
Nombre entier (byte, short, int, long)
Un nombre entier est un nombre sans virgule qui peut tre exprim dans diffrentes bases :
Base dcimale : L'entier est reprsent par une suite de chiffre unitaire (de 0 9) ne devant pas
commencer par le chiffre 0
Base hexadcimale : L'entier est reprsent par une suite d'units (de 0 9 ou de A F (ou a f))
devant commencer par 0x ou 0X
Base octale : L'entier est reprsent par une suite d'units (incluant uniquement des chiffres de 0
7) devant commencer par 0
Lorsqu'un nombre est trop grand pour tre reprsent par un int, il faut explicitement le dclarer
comme tant un long en lui rajoutant un L :
long n = 9876543210L ;
Les entiers sont signs par dfaut, cela signifie qu'ils comportent un signe. Pour stocker
l'information concernant le signe (en binaire), les ordinateurs utilisent le complment deux
Nombre virgule (float, double)
Un nombre virgule flottante est un nombre virgule, il peut toutefois tre reprsent comme
un entier dcimal : 895

un nombre virgule (en utilisant la notation amricaine avec un point) : 845.32
un nombre exponentiel, c'est--dire un nombre (ventuellement virgule) suivi de la lettre e (ou
E), puis d'un entier correspondant la puissance de 10 (sign ou non, c'est--dire prcd d'un +
ou d'un -)
15
2.75e-2
35.8E+10
.25e-2
En ralit, les nombres rels sont des nombres virgule flottante, c'est--dire un nombre dans
lequel la position de la virgule n'est pas fixe, et est repre par une partie de ses bits (appele
l'exposant), le reste des bits permettent de coder le nombre sans virgule (la mantisse).
Les nombres de type float sont cods sur 32 bits dont :
23 bits pour la mantisse

8 bits pour l'exposant
1 bit pour le signe
Les nombres de typedouble sont cods sur 64 bits dont :
52 bits pour la mantisse

11 bits pour l'exposant
1 bit pour le signe
La prcision de nombres rels est approche. Elle dpend du nombre de dcimales, elle sera
au moins :
de 6 chiffres significatifs pour le type float

de 15 chiffres significatifs pour le type double
Lorsque l'on crit directement une valeur flottante dans le code, elle est considre par dfaut
comme un double. Si on veut rduire sa prcision pour qu'elle reprsente un float, il faut
explicitement lui rajouter un F :
float x = 2.F;
Caractre (char)
Le type char (provenant de l'anglais character) permet de stocker la valeur Unicode, code
sur 16 bits, d'un caractre, c'est--dire un nombre entier cod sur 16 bits, soit 65535 caractres
!
Par consquent il est possible de stocker un caractre accentu dans une variable de type char.
Si jamais on dsire par exemple stocker la lettre B, on pourra dfinir cette donne soit par son
code Unicode '\u0066', soit en plaant directement le caractre entre apostrophes 'B', on peut
ainsi copier-coller un caractre Unicode et le mettre directement dans son code sans avoir
connatre sa valeur Unicode.
Chanes de caractres (String)
Les chanes de caractres ne correspondent pas un type de donnes mais une classe, ce qui
signifie qu'une chane de caractre est un objet possdant des attributs et des mthodes. Une
chane peut donc tre dclare de la faon suivante :
16
String s = "Chaine de caractres ;
Conversion de type de donnes (casting)

On appelle conversion de type de donnes, parfois transtypage (traduction de l'anglais
casting), le fait de modifier le type d'une donne en une autre.
conversion implicite : une conversion implicite consiste en une modification du type de

donne effectue automatiquement par le compilateur. Cela signifie que lorsque l'on va
stocker un type de donne dans une variable dclare avec un autre type, le compilateur ne
retournera pas d'erreur mais effectuera une conversion implicite de la donne avant de
l'affecter la variable. Par exemple la conversion d'un type primitif vers son Wrapper est
implicite.
int n = 8 ;
Integer m = n ;
conversion explicite : une conversion explicite (appele aussi opration de cast) consiste en
une modification du type de donne force. Cela signifie que l'on utilise un oprateur dit de
cast pour spcifier la conversion. L'oprateur de cast est tout simplement le type de donne,
dans lequel on dsire convertir une variable, entre des parenthses prcdant la variable.
double x = 8.324 ;
int n = (int) x ;
x contiendra aprs affectation la valeur 8.
17
Java : les variables
Le concept de variable
Une variable est une donne (un objet ou un type primitif) repre par son nom, et qui pourra
tre lu, ou modifie lors de l'excution du programme. Les variables en langage Java sont
types, c'est--dire que les donnes contenues dans celles-ci possdent un type, ainsi elles sont
donc stockes une adresse mmoire et occupent un nombre d'octets dpendant du type de
donne stocke.
PUBLICIT
inRead invented by Teads
En Java, les noms de variables peuvent tre aussi long que l'on dsire, toutefois le compilateur
ne tiendra compte "que" des 247 premiers caractres. De plus, elles doivent rpondre
certains critres :
un nom de variable ne peut comporter que des lettres, des chiffres (les caractres _ et $
peuvent tre utiliss mais ne devrait pas l'tre pour des variables)
un nom de variable ne peut pas commencer par un chiffre et ne doit pas comporter d'espace
les noms de variables ne peuvent pas tre les noms rservs du langage :
abstract, assert
boolean, break, byte
case, catch, char, class, const, continue
default, do, double
else, enum, extends
false, final, finally, float, for
goto
if, implements, import, instanceof, int, interface
long
native, new, null
package, private, protected, public
return
short, static, sctrictfp, super, switch, synchronized
this, throw, throws, transient, true, try
void, volatile
while
Les noms de variables sont sensibles la casse (Java fait la diffrence entre les lettres
minuscules et majuscules, avec ou sans accent), il faut donc veiller respecter la casse des
noms !
Par convention, un nom de variable est crit en minuscules, sans accent, ni _ ou $. En
18
revanche lorsqu'il est compos de plusieurs mots, on peut utiliser une majuscule pour l'initiale
de chaque nouveau mot.
Nom de variable correct Nom de variable incorrect Raison

nomDeVariable Nom de Variable comporte des espaces
nomDeVariable123 123NomDeVariable commence par un chiffre
totoAtMailCityDotCom toto@mail-city.com caractres spciaux @ - et .
continuer continue nom rserv
La dclaration de variables
Pour pouvoir utiliser une variable, il faut la dfinir, c'est--dire lui donner un nom, mais
surtout un type de donne stocker afin qu'un espace mmoire conforme au type de donne
qu'elle contient lui soit rserv.
Une variable se dclare de la faon suivante :
type nomDeVariable;
Ou bien s'il y a plusieurs variables du mme type :

type nomDeVariable1, nom_de_variable2;
Java impose que les variables soient imprativement dclares avant d'tre utilise.
Java permet de dfinir une variable n'importe quel endroit du code.
Affectation d'une donne une variable

La dclaration d'une variable rserve un emplacement mmoire o stocker la variable, et une
valeur par dfaut (gnralement 0, null ou false), pour modifier cette valeur par dfaut, il faut
faire une affectation, c'est--dire prciser la donne qui va tre stocke l'emplacement
mmoire qui a t rserv.
Pour cela on utilise l'oprateur d'affectation "=" :
nomDeVariable = valeur;
Il est aussi possible d'initialiser les valeurs lors de leurs dclarations.

type nomDeVariable = valeur;
Exemple : Pour stocker le caractre B dans une variable que l'on a appellera caractere, il
faudrait crire :
char caractere = 'B';
19
Ce qui signifie "stocker la valeur Unicode de la lettre B dans la variable nomme 'caractere'".
Porte (visibilit) des variables

Selon l'endroit o on dclare une variable, celle-ci pourra tre accessible (visible) de partout
dans le code ou bien que dans une portion confine de celui-ci ( l'intrieur d'une mthode par
exemple), on parle de porte d'une variable.
Lorsqu'une variable est dclare directement dans la classe, c'est--dire l'extrieur de toute
mthode, elle sera accessible dans toute la classe. On parle alors de champ de la classe (fields,
en anglais). Elle reprsente l'tat de l'objet courant (ou avec le mot cl static, l'tat de la classe
elle-mme).
Lorsque l'on dclare une variable l'intrieur d'un bloc d'instructions (entre des accolades), sa
porte se restreint l'intrieur de ce bloc (dans les lignes qui suit sa dclaration), on parle
alors de variable locale.
Il est interdit d'avoir deux variables de mme nom si elles ont une porte commune. Il serait
alors impossible de les distinguer...
Dfinition de constantes
Une constante est une donne dont la valeur est inchangeable lors de l'excution d'un
programme. Le mot cl final permet de faire cela. Toutefois on ne peut vritablement parler
de constantes en Java que pour les types primitifs, car pour un objet le mot cl final impose
seulement que la rfrence de l'objet n'est pas modifiable, mais les champs de lobjet peuvent
tre modifis malgr tout.
Par convention, et pour les distinguer des variables, les constantes sont crites entirement en
majuscules, et le caractre _ peut tre utilis pour sparer deux mots.
final int MA_CONSTANTE = 12
Aura pour effet de dfinir une variable de type int possdant la valeur 12 et ne pouvant pas tre
modifie dans la suite du code, auquel cas le compilateur gnrera une erreur...
20
Java les oprateurs
Qu'est-ce qu'un oprateur ?
Les oprateurs sont des symboles qui permettent de manipuler des variables, c'est--dire
effectuer des oprations, les valuer, ... On distingue plusieurs types d'oprateurs :
les oprateurs de calcul

les oprateurs d'assignation
les oprateurs d'incrmentation
les oprateurs de comparaison
les oprateurs logiques
(les oprateurs bit--bit)
(les oprateurs de rotation de bit)
Les oprateurs de calcul

Les oprateurs de calcul permettent de modifier mathmatiquement la valeur d'une variable
Oprateur Dnomination Effet Exemple Rsultat (int

x=7)
+ oprateur Ajoute deux valeurs x+3 10
d'addition
- oprateur de Soustrait deux valeurs x-3 4
soustraction
* oprateur de Multiplie deux valeurs x*3 21
multiplication
/ oprateur de Calcul le quotient de la x/3 2
division division de deux valeurs
% oprateur de Calcul le reste de la x%3 1
congruence division de deux valeurs
= oprateur Affecte une valeur x=3 Met la valeur 3
d'affectation une variable dans la variable x
Les oprateurs d'assignation

Ces oprateurs permettent de simplifier des oprations telles quajouter une valeur dans une
variable et stocker le rsultat dans la variable.
Une telle opration s'crirait habituellement de la faon suivante par exemple : x=x+2
Avec les oprateurs d'assignation il est possible d'crire cette opration sous la forme suivante
: x+=2
Ainsi, si la valeur de x tait 7 avant opration, elle sera de 9 aprs...
Les autres oprateurs du mme type sont les suivants :
21
Oprateur Effet
+= addition deux valeurs et stocke le rsultat dans la variable ( gauche)
-= soustrait deux valeurs et stocke le rsultat dans la variable
*= multiplie deux valeurs et stocke le rsultat dans la variable
/= divise deux valeurs et stocke le quotient dans la variable
%= divise deux valeurs et stocke le reste dans la variable
Les oprateurs d'incrmentation

Ce type d'oprateur permet de facilement augmenter ou diminuer d'une unit une variable.
Ces oprateurs sont trs utiles pour des structures telles que des boucles, qui ont besoin d'un
compteur (variable qui augmente de un en un).
Un oprateur de type x++ permet de remplacer des notations lourdes telles que x=x+1 ou
bien x+=1
Oprateur Dnomination Effet Syntaxe Rsultat (int x=7)

++ Incrmentation Augmente d'une unit la x++ ou 8
variable ++x
-- Dcrmentation Diminue d'une unit la x-- ou --x 6
variable
Remarque : la diffrence entre x++ ou ++x se fait ressentir lorsque l'on combine plusieurs
oprations.
Avec x++ on utilise la valeur de x puis on ajoute 1, alors qu'avec ++x on ajoute d'abord 1,
puis on utilise le rsultat. Il en va de mme pour x-- et --x.
Exemples (pour x=7)

int y=x++ ;
Y est initialis 7, puis x est incrment 8
int y=++x ;
x est incrment 8, puis y est initialis 8
Les oprateurs de comparaison

Oprateur Dnomination Effet Exemple Rsultat
== oprateur d'galit Compare deux valeurs x==3 Retourne true si
ne pas et vrifie leur galit X est gal 3,
confondre avec le sinon false
signe d'affectation
=
22
< oprateur Vrifie qu'une variable x<3 Retourne true si
d'infriorit stricte est strictement X est infrieur
infrieure une valeur 3, sinon false
<= oprateur Vrifie qu'une variable x<=3 Retourne true si
d'infriorit est infrieure ou gale X est infrieur
une valeur ou gal 3,
sinon false
> oprateur de Vrifie qu'une variable x>3 Retourne true si
supriorit stricte est strictement X est suprieur
suprieure une valeur 3, sinon false
>= oprateur de Vrifie qu'une variable x>=3 Retourne true si
supriorit est suprieure ou gale X est suprieur
une valeur ou gal 3,
sinon false
!= oprateur de Vrifie qu'une variable x !=3 Retourne true si
diffrence est diffrente d'une X est diffrent
valeur de 3, sinon false
Les oprateurs logiques (boolens)

Ce type d'oprateur permet de vrifier si plusieurs conditions sont vraies :
Oprateur Dnomination Effet Syntaxe

|| OU logique Retourne true si au moins une des deux condition1 ||
conditions vaut true (ou false sinon) condition2
&& ET logique Retourne true si les deux conditions condition1 &&
valent true (ou false sinon) condition2
! NON logique Retourne true si la variable vaut false, et !condition
false si elle vaut true)
Remarque : il n'est pas toujours ncessaire de faire tous les tests pour connatre le rsultat d'un
calcul.
Par exemple le rsultat de (true || x), vaudra toujours true quel que soit la valeur x.
Il est donc intressant de savoir que Java value les valeurs de gauche droite pour
conomiser les calculs.
Les oprateurs bit--bit

Si vous ne comprenez pas ces oprateurs cela n'est pas important, vous n'en aurez
probablement pas l'utilit. Pour ceux qui voudraient comprendre, rendez- vous aux chapitres
suivants :
comprhension du binaire
reprsentation des donnes
Instructions arithmtiques et logiques en assembleur
23
Ce type d'oprateur traite ses oprandes comme des donnes binaires, plutt que des donnes
dcimales, hexadcimales ou octales. Ces oprateurs traitent ces donnes selon leur
reprsentation binaire mais retournent des valeurs numriques standards dans leur format
d'origine.
Les oprateurs suivants effectuent des oprations bit--bit, c'est--dire avec des bits de mme
poids.
Oprateur Dnomination Effet Syntaxe Rsultat

& ET bit--bit Retourne 1 si les deux bits de 9 & 12 (1001 8 (1000)
mme poids sont 1 & 1100)
| OU inclusif Retourne 1 si l'un ou l'autre des 9 | 12 (1001 | 13
deux bits de mme poids est 1 1100) (1101)
(ou les deux)
^ OU exclusif Retourne 1 si l'un des deux bits 9 ^ 12 (1001 5 (0101)
de mme poids est 1 (mais pas ^ 1100)
les deux)
Les oprateurs de rotation de bit

Si vous ne comprenez pas ces oprateurs cela n'est pas important, vous n'en aurez
probablement pas l'utilit. Pour ceux qui voudraient comprendre, rendez- vous aux chapitres
suivants :
comprhension du binaire
reprsentation des donnes
Instructions arithmtiques et logiques en assembleur
Ce type d'oprateur traite ses oprandes comme des donnes binaires, plutt que des donnes
dcimales, hexadcimales ou octales. Ces oprateurs traitent ces donnes selon leur
reprsentation binaire mais retournent des valeurs numriques standards dans leur format
d'origine.
Les oprateurs suivants effectuent des rotations sur les bits, c'est--dire qu'il dcale chacun
des bits d'un nombre de bits vers la gauche ou vers la droite. Le premier oprande dsigne la
donne sur laquelle on va faire le dcalage, la seconde dsigne le nombre de bits duquel elle
va tre dcale.
Oprateur Dnomination Effet Syntaxe Rsultat

<< Rotation gauche Dcale les bits vers la gauche 6 << 1 12
(multiplie par 2 chaque (110 << (1100)
dcalage). Les bits qui sortent 1)
gauche sont perdus, tandis que
des zros sont insrs droite
>> Rotation droite Dcale les bits vers la droite 6 >> 1 3 (0011)
avec conservation (divise par 2 chaque dcalage). (0110 >>
du signe Les bits qui sortent droite sont 1)
perdus, tandis que le bit non-nul
24
de poids plus fort est recopi
gauche
>>> Rotation droite Dcale les bits vers la droite 3 >>> 1 1 (0001)
avec remplissage (divise par 2 chaque dcalage). (0011
de zros Les zros qui sortent droite >>> 1)
sont perdus, tandis que des zros
sont insrs gauche
Les priorits
Lorsque l'on associe plusieurs oprateurs, il faut que le compilateur sache dans quel ordre les
traiter, voici donc dans l'ordre dcroissant les priorits de tous les oprateurs :
Priorit des oprateurs

++++++++++++++++ () [] .
+++++++++++++++ -- ++ ! ~ - (un + (un (casting) new
oprande) oprande)
++++++++++++++ * / %
+++++++++++++ + -
++++++++++++ << >> >>>
+++++++++++ < <= >= > instanceof
++++++++++ == !=
+++++++++ &
++++++++ ^
+++++++ |
++++++ &&
+++++ ||
++++ ? :
+++ = += -= *= /= %= &=
++ <<= >>= >>>= ^= |=
+ ,
25
Java - Les Structures conditionnelles
Qu'est-ce qu'une structure conditionnelle ?
On appelle structure conditonnelle les instructions qui permettent de tester si une condition
est vraie ou non. Ces structures conditionnelles peuvent tre associes des structures qui se
rptent suivant la ralisation de la condition, on appelle ces structures des structures de
boucle
La notion de bloc
Une expression suivie d'un point-virgule est appele instruction. Par exemple a++; est une
instruction.
Lorsque l'on veut regrouper plusieurs instructions, on peut crer ce que l'on appelle un bloc,
c'est--dire un ensemble d'instructions (suivies respectivement par des point-virgules) et
comprises entre les accolades { et }.
Les instructions if, while et for peuvent par exemple tre suivies d'un bloc d'instructions
excuter...
L'instruction if
L'instruction if est la structure de test la plus basique, on la retrouve dans tous les langages
(avec une syntaxe parfois diffrente...). Elle permet d'excuter une srie d'instructions
lorsqu'une condition est ralise.
La syntaxe de cette expression est la suivante :
if (condition ralise) {
liste d'instructions si la condition est ralise
}
else {
liste d'instructions si la condition n'est pas ralise
}
Remarque :
la condition doit tre entre des parenthses

il est possible de dfinir plusieurs conditions remplir avec les oprateurs ET et OU (&& et
||)
Par exemple l'instruction suivante teste si les deux conditions sont vraies :
if ((condition1) && (condition2))

L'instruction suivante excutera les instructions si l'une ou l'autre des deux conditions est vraie
if ((condition1) || (condition2))
s'il n'y a qu'une seule instruction, les accolades ne sont pas ncessaires...
s'il n'y a pas d'instruction excuter lorsque la condition n'est pas ralise, on peut enlever
le else et le bloc qui suit.
26
Affectation conditionnelle (oprateur ternaire)
Lorsque les instructions du if et du else consistent donner une valeur une variable, il est
possible de faire un test avec une structure beaucoup moins lourde grce l'oprateur ternaire
:
Variable = condition ? valeur_si_vrai : valeur_si_faux

Par exemple ces deux codes sont quivalents (ils donnent min la plus petite valeur entre a et b)
if (a<b)
min=a ;
else
min=b ;
min = a<b ? a : b ;
Remarques :
Contrairement la boucle if, il n'est pas ncessaire que la condition soit entre parenthses.
Lorsque la condition est vraie, la valeur gauche des " : " est donne la variable
Lorsque la condition est fausse, la valeur droite des " : " est donne la variable
L'instruction switch
L'instruction switch permet de faire plusieurs tests de valeurs sur le contenu d'une mme
variable. Ce branchement conditionnel simplifie beaucoup le test de plusieurs valeurs d'une
variable, car cette opration aurait t complique (mais possible) avec des if imbriqus. Sa
syntaxe est la suivante :
switch (variable) {
case valeur1 :
Liste d'instructions
break;
case valeur2 :
break;
case valeurN... :
break;
default:
}
Les parenthses qui suivent le mot cl switch indiquent une expression dont la valeur est
teste successivement par chacun des case. Lorsque l'expression teste est gale une des
valeurs suivant une case, la liste d'instruction qui suit celui-ci est excut. Le mot cl break
indique la sortie de la structure conditionnelle, s'il n'est pas mis alors toutes les instructions
suivantes seront galement excutes. Le mot cl default est mettre la fin, et prcde la
liste d'instructions excuter si l'expression n'est jamais gale aux valeurs prcdentes.
27
N'oubliez pas d'insrer les instructions break entre chaque
test, leur absence est difficile dtecter puisqu'il ne
s'agit pas formellement d'une erreur...
L'instruction switch ne fonctionne que sur des types simples (int, short, char ou byte) !
Les boucles
Les boucles sont des structures qui permettent d'excuter plusieurs fois la mme srie
d'instructions jusqu' ce qu'une condition ne soit plus ralise...
On appelle parfois ces structures instructions rptitives ou bien itrations.
La faon la plus commune de faire une boucle, est de crer un compteur (une variable qui
s'incrmente, c'est--dire qui augmente de 1 chaque tour de boucle) et de faire arrter la
boucle lorsque le compteur dpasse une certaine valeur.
Remarque : les trois boucles de base sont quivalentes, il est toujours possible de rcrire
chacune d'elle avec l'une des deux autres.
La boucle for
L'instruction for permet d'excuter plusieurs fois la mme srie dinstructions : c'est une
boucle !
Dans sa syntaxe, il suffit de prciser le nom de la variable qui sert de compteur (et
ventuellement sa valeur de dpart, la condition sur la variable pour laquelle la boucle s'arrte
(basiquement une condition qui teste si la valeur du compteur dpasse une limite) et enfin une
instruction qui incrmente (ou dcrmente) le compteur.
La syntaxe de cette expression est la suivante :
for (compteur ; condition; modification du compteur) {

liste d'instructions
}
Par exemple :
int i ;
for (i=1 ; i<6 ; i++) {
System.out.println(i) ;
}
Cette boucle affiche 5 fois la valeur de i, c'est--dire 1, 2, 3, 4, 5
Elle commence i=1, vrifie que i est bien infrieur 6, etc... Jusqu atteindre la valeur i=6, pour
laquelle la condition ne sera plus ralise, la boucle s'interrompra et le programme continuera son
cours.
Remarque : Java autorise la dclaration de la variable de boucle dans l'instruction for elle-
mme. On peut mme dclarer d'autres variables en mme temps, par exemple pour dfinir la
condition d'arrt :
28
for (int i=0, n=10 ; i<n ; i++) {
System.out.println(i);
}
Remarque :
il faut toujours s'assurer que la boucle s'arrte bien un moment

une instruction d'affichage System.out.println(); dans votre boucle est un bon moyen pour
vrifier la valeur du compteur pas pas en l'affichant !
il faut bien compter le nombre de fois que l'on veut faire excuter la boucle :
o for(i=0; i<10; i++) excute 10 fois la boucle (i de 0 9)
o for(i=0; i<=10; i++) excute 11 fois la boucle (i de 0 10)
o for(i=1; i<10; i++) excute 9 fois la boucle (i de 1 9)
o for(i=1; i<=10; i++) excute 10 fois la boucle (i de 1 10)
La boucle while
La boucle while reprsente un autre moyen d'excuter plusieurs fois la mme srie
d'instructions.
La syntaxe est la suivante :
while (condition ralise) {

}
Cette instruction excute la liste d'instructions tant que (while est un mot anglais qui signifie
tant que) la condition est ralise.
La condition de sortie pouvant tre n'importe quelle
condition, il est souvent moins ais de savoir si la boucle
s'arrte, mais il est important de toujours s'en assurer.
La boucle do while
La boucle do while est une variante de la boucle while, o la condition d'arrt est teste aprs que les
instructions aient t excutes.
do {
} while (condition ralise) ;
Attention : n'oubliez pas de mettre un point-virgule aprs la condition de la boucle do while, mais
n'en mettez surtout pas une boucle for ou une boucle while.
La boucle for each

La boucle for each n'est pas une boucle comparable aux trois prcdentes, car elle s'utilise dans un
cadre trs particulier, lorsqu'il faut itrer les diffrents lments d'un ensemble (un tableau, une liste
etc...).
29
for (type variable : ensemble) {

instructions
}
Par exemple pour afficher tous les lments d'un tableau d'entiers, ces deux codes sont quivalents :
for (int i=0, n=tableau.length; i<n; i++)

System.out.println(tableau[i]);
for (int e : tableau)

System.out.println(e);
Dans le premier code on itrait les indices du tableau, alors que dans le deuxime, on itre
directement sur les lments du tableau.
Remarque :
Dans la majorit des cas o elle peut s'utiliser, la boucle for each est plus rapide qu'une
boucle for.
On a ici un contrle moindre sur l'ordre des lments, mais Java assure que tous les lments
seront utiliss (on na pas compter soi-mme le nombre d'lments) et qu'ils seront pris
"dans l'ordre" (lorsque cet ordre existe).
Saut inconditionnel
Il peut tre ncessaire de faire sauter une ou plusieurs valeurs la boucle sans pour autant
mettre fin celle-ci.
La syntaxe de cette expression est "continue ;" (cette instruction se place dans la boucle), on
l'associe gnralement une structure conditionnelle, sinon les lignes situes entre cette
instruction et la fin de la boucle seraient obsoltes.
Exemple : Imaginons que l'on veuille imprimer pour x allant de 1 10 la valeur de 1/(x-7) ...
il est vident que pour x=7 il y aura une erreur. Heureusement, grce l'instruction continue il
est possible de traiter cette valeur part puis de continuer la boucle !
x=1;
for (int x=0; x<=10; x++) {

if (x == 7) {
System.out.println("Division par zro!");
continue;
}
double a = 1.0/(x-7);
System.out.println(a);
}
Arrt inconditionnel
A l'inverse, il peut tre voulu d'arrter prmaturment la boucle, pour une autre conditon que
celle prcise dans l'en-tte de la boucle. L'instruction break permet d'arrter une boucle (for
30
ou bien while). Il s'agit, tout comme continue, de l'associer une structure conditionnelle, sans
laquelle la boucle ne ferait jamais plus d'un tour !
Dans l'exemple de tout l'heure, par exemple si l'on ne savait pas quel moment le
dnominateur (x-7) s'annule (bon...OK...pour des quations plus compliques par exemple) il
serait possible de faire arrter la boucle en cas d'annulation du dnominateur, pour viter une
division par zro!
for (int x=1; x<=10; x++) {
a = x-7;
if (a == 0) {
System.out.println("division par 0");
break;
}
System.out.println(1.0/a);
}
31
Java - Les Structures fonctionnelles
Note : cette page prsente des concepts introduits en Java 8 qui ne peuvent pas tre utiliss
dans les versions prcdentes.
Interface fonctionnelle
Une interface fonctionnelle est une interface qui ne dfinit qu'une seule mthode
implmenter.
Une telle interface devrait dsormais possder l'annotation @FunctionalInterface, mme si

elle est facultative afin d'assurer la rtro-compatibilit avec les codes dvelopps avant Java 8.
Exemple (en Java 8)
@FunctionalInterface
public interface Comparator<T> {
// rsultat <0 si o1<o2, =0 si o1=o2 et >0 si o1>o2
int compare(T t1, T t2) ;
}
Remarque : avec l'apparition dans Java 8 des mthodes par dfaut, il est possible d'avoir une
interface avec plusieurs mthodes par dfaut. Une interface reste nanmoins fonctionnelle tant
qu'il y a une et une seule mthode implmenter.
PUBLICIT
Expressions Lambda
Jusqu' Java 7, pour utiliser une interface, il tait ncessaire de dfinir une classe qui
implmente cette interface et instancier un objet de cette classe (parfois au travers de classes
anonymes).
Exemple (en Java 5+)
Comparator<Integer> comp = new Comparator<Integer>() {
@Override
public int compare(Integer i1, Integer i2) {
return i1-i2 ;
}
}
Avec les interfaces fonctionnelles il est dsormais possible de simplifier l'criture de ces
interfaces. En effet, en partant du principe qu'il n'y a qu'une seule mthode, il n'est plus
vraiment utile d'en rappeler son nom.
32
Les lambdas expressions en Java 8 permettent donc d'crire :
Comparator<Integer> comp = (Integer i1, Integer i2) -> {

return i1-i2 ;
}
La syntaxe
(Type paramtre, ...) -> { corps }
dfinit une fonction lambda.
Si le calcul se fait sur une seule ligne comme dans notre exemple, on peut enlever les
accolades et avoir directement :
Comparator<Integer> comp =
(Integer i1, Integer i2) -> i1-i2;
Lorsqu'il n'y a pas d'ambiguts quant au type de donnes manipules, il est mme possible de
laisser Java s'occuper du typage des variables. On pourra donc encore simplifier :
Comparator<Integer> comp = (i1, i2) -> i1-i2;
Il est ainsi possible de rdiger plus clairement son code, lorsqu'au travers d'une mthode un
des paramtres est une interface fonctionnelle.
Exemple (en Java 8)
List<Integer> list = Arrays.asList(7,4,1,8,5,2,9,6,3);
// tri en ordre croissant

Collections.sort(list, (a,b) -> a-b);
System.out.println(list); // [1, 2, 3, 4, 5, 6, 7, 8, 9]
// tri en ordre dcroissant

Collections.sort(list, (a,b) -> b-a);
System.out.println(list); // [9, 8, 7, 6, 5, 4, 3, 2, 1]
Rfrences de mthodes
Lorsque le code est un peu long ou utilis plusieurs fois, il faut organiser son code. Pour les
interfaces avant Java 8, il s'agissait de crer une nouvelle classe pour chaque implmentation.
Exemple (en Java 5+)
public class Test {

public static class AscendingIntegerComparator
implements Comparator<Integer> {
@Override
33
public int compare(Integer i1, Integer i2) {
return i1 - i2;
}
}
public static void main(String[] args) {

Collections.sort(list, new AscendingIntegerComparator());
System.out.println(list);
}
}
Comme dans notre exemple, la plupart des implmentations des interfaces fonctionnelles,
n'avaient pas d'attributs privs, n'utilisait que le constructeur par dfaut et ne servait jamais de
l'hritage implicite d'Object.
Finalement, une mthode static nous suffirait et c'est ce qu'il est possible de faire avec les
rfrences de mthodes :
Exemple (en Java 8)
public class Test {

public static int ascendingIntegerComparator(
Integer i1, Integer i2) {
return i1 - i2;
}

Collections.sort(list, Test::ascendingIntegerComparator);
System.out.println(list);
}
}
La notation
classe :: mthode
fait donc rfrence une mthode statique. Dans notre exemple le second paramtre de sort
(de type Comparator<T>) n'est donc plus un objet, mais une mthode !
On peut gnraliser les rfrences de mthodes aux constructeurs, en utilisant la "mthode"

new, ou n'importe quelle mthode non static en la liant un objet particulier.
Exemples
public interface Supplier<T> {
T get();
}
public interface Function<T, R> {
R apply(T t);
}
34
Function<Integer, List<String>> fun = ArrayList::new;
List<String> list = fun.apply(3); // new ArrayList(3)
Supplier<Integer> size = list::size;

System.out.println(size.get()); // list.size() = 0
list.add("toto");
System.out.println(size.get()); // list.size() = 1
}
Remarque : les interfaces Supplier<T>, Function<T,R>, ainsi qu'une quarantaine d'autres sont
spcifies dans le package java.util.function, accompagnes de mthodes par dfaut
permettant leur manipulation.
Plus qu'une nouvelle syntaxe

Puisque l'on ne manipule plus des objets, mais directement des mthodes, Java opre des
optimisations dans le code.
Exemple :
public static boolean isGreater(Integer a, Integer b,

Comparator<Integer> comp) {
return comp.compare(a,b) > 0;
}
Des diffrentes critures prsentes, il est prfrable d'utiliser
isGreater(x, y, (a,b) -> a-b);

ou
isGreater(x, y, Test::ascendingIntegerComparator);
.
Ainsi Java pourra modifier le code l'excution et faire :
Pseudo code ( l'excution) :
public static boolean isGreater(x, y, (a,b) -> a-b) {

return (x-y) > 0;
}
public static boolean isGreater(x, y,

Test::ascendingIntegerComparator) {
return Test.ascendingIntegerComparator(x, y) > 0;
}
En revanche, ce dernier code est dconseill :
Comparator<Integer> comp = (a,b) -> a-b;

boolean greater = isGreater(x, y, comp);
35
En effet Java serait oblig pour traiter ces instructions de crer une nouvelle classe qui hrite
de Object et implmente Comparator, de l'instancier et passer l'objet en paramtre de la
mthode, qui ne pourrait pas tre optimis.
Donc mme si on gagne en clart du code grce l'criture lambda de l'interface

fonctionnelle, il ne faut pas perdre de vue que l'intrt est surtout dans la cration et le passage
de mthode par rfrences.
36
Les classes Java
La notion d'objet
Le langage Java intgre fortement le concept objet, il s'agit donc d'un langage orient objet
(LOO). Le terme langage orient objet est plus qu'une simple appellation de plus pour
dsigner un type de langage, il s'agit rellement d'une faon de programmer part entire, un
tat d'esprit...
Pour comprendre clairement le concept d'objet, reportez-vous la partie Programmation
oriente objet!
Les classes avec Java

Pour pouvoir manipuler des objets, il est essentiel de dfinir des classes, c'est--dire dfinir la
structure d'un objet. Cette dfinition avec Java se fait de la manire suivante :
public class NomDeLaClasse {

// Instructions permettant de dfinir la classe
}
Avec Java il ne faut pas ajouter de point-virgule la fin du bloc de dfinition de la classe,
contrairement au langage C++...
NomDeLaClasse reprsente bien videmment le type d'objet dsign par la classe ou du

moins le nom que vous leur attribuez.
Remarque :
Par convention le nom d'une classe commence par une majuscule

Une classe public doit obligatoirement tre code dans un fichier .java qui porte son nom, en
revanche on peut coder autant de classes "non-public" que l'on veut dans le mme fichier.
Dclaration des donnes membres

Jusqu'ici notre classe est vide (elle est toutefois syntaxiquement correcte), c'est--dire qu'elle
ne contient ni donnes (appeles donnes membres) ni traitements (fonctions appeles
mthodes). En ralit elle hrite malgr tout des proprits de la classe Object qui est
commune toutes les classes.
Les donnes membres sont des variables stockes au sein d'une classe. Elles doivent tre
prcdes de leur type et (ventuellement) d'une tiquette prcisant leur porte, c'est--dire les
classes ayant le droit d'y accder.
Ces tiquettes sont au nombre de trois :
public
private
protected
37
Pour comprendre en dtail ces tiquettes, reportez-vous au chapitre sur l'encapsulation. En
l'absence d'aucune de ces trois tiquettes, c'est par dfaut un quatrime mode qui est utilis,
parfois appel "friendly", qui se comporte comme tant public au sein du package de la classe,
et private en dehors.
Ainsi, une classe comportant quatre donnes membres peut par exemple ressembler ceci :
public class Voiture {

public String marque;
private double vitesse;
protected float prix;
String immatriculation;
}
Dclaration des mthodes

Les donnes membres permettent de conserver des informations relatives la classe, tandis
que les mthodes reprsentent les traitements qu'il est possible de raliser avec les objets
instancis de la classe. Elles permettent en particulier de garantir l'intgrit de ces donnes
membres (gnralement private) en effectuant sur celles-ci uniquement des traitements
corrects.
La dfinition d'une mthode se fait en dfinissant le prototype et le corps de la fonction

l'intrieur de la classe en une opration.
Voici donc la syntaxe d'une classe avec des mthodes :
public class Nom_de_la_classe {

// Instructions permettant de dfinir les donnes membres de la classe ;
// Instructions permettant de dfinir les mthodes de la classe ;
TypeDeValeurRenvoye nomDeLaMethode(TypeDuParametre1 nomDuParametre1,

TypeDuParametre2 nomDuParametre2) {
// Instructions du corps de la mthode
}
}
Remarque :
Par convention le nom d'une mthode commence par une minuscule

L'encapsulation concerne galement les mthodes de manipulation des donnes membres. On
peut donc placer l'une des trois tiquettes (public, protected, private) devant les mthodes.
38
Java : Les mthodes
La notion de fonction et de mthode
On appelle fonction un sous-programme qui permet d'effectuer un ensemble d'instructions par
simple appel de la fonction dans le corps du programme principal. Les fonctions permettent
d'excuter dans plusieurs parties du programme une srie d'instructions, cela permet une
simplicit du code et donc une taille de programme minimale. D'autre part, une fonction peut
faire appel elle-mme, on parle alors de fonction rcursive (il ne faut pas oublier de mettre
une condition de sortie au risque sinon de ne pas pouvoir arrter le programme...).
Une mthode est une fonction faisant partie d'une classe. Elle permet d'effectuer des
traitements sur (ou avec) les donnes membres des objets. Puisqu'en Java on ne manipule que
des classes, il n'y aura formellement que des mthodes, mme si on pourra parler de fonction
pour des mthodes static qui ne manipule aucune des donnes membres.
La dclaration d'une mthode

Avant d'tre utilise, une mthode doit tre dfinie car pour l'appeler dans une classe il faut
que le compilateur la connaisse, c'est--dire qu'il connaisse son nom, ses arguments et les
instructions qu'elle contient. La dfinition d'une mthode s'appelle "dclaration". La
dclaration d'une fonction se fait selon la syntaxe suivante :
TypeDeRetour nomDeLaMethode(Type1 argument1, Type2 argument2) {

}
Remarque :
TypeDeRetour reprsente le type de valeur que la mthode va retourner, cela peut-tre un

type primitif, une classe, ou alors le mot-cl void si la mthode ne retourne aucune valeur.
le nom de la mthode suit les mmes rgles que les noms de variables :
o le nom doit tre crit en minuscule, sauf pour les initiales de chaque nouveau mot
o un nom de mthode peut comporter des chiffres, mais pas pour le premier caractre
o les caractres spciaux _ et $ peuvent tre utiliss mais ne devraient pas l'tre
o le nom de la mthode est sensible la casse (diffrence entre les minuscules et
majuscules)
Les arguments sont facultatifs, mais s'il n'y a pas d'arguments, les parenthses doivent rester
prsentes
Il ne faut pas oublier de refermer les parenthses et les accolades
Le nombre d'accolades ouvertes (mthode, boucles et autres structures) doit tre gal au
nombre d'accolades fermes !
La mme chose s'applique pour les parenthses, les crochets ou les guillemets !
39
Une fois cette tape franchie, votre mthode ne s'excutera pas tant que l'on ne fait pas appel
elle quelque part dans la classe !
Appel de mthode
Pour excuter une mthode, il suffit de faire appel elle en crivant l'objet auquel elle
s'applique (celui qui contient les donnes), le nom de la mthode (en respectant la casse),
suivie de ses arguments entre parenthse :
objet.nomDeLaMethode(argument1,argument2);
Remarque :
si vous excutez une mthode sur l'objet courant (this), c'est dire que vous utilisez dans une
classe, une mthode de la mme classe, alors il est inutile de prciser que this est l'objet auquel
s'applique la mthode.
le point-virgule signifie la fin d'une instruction pour distinguer les diffrents blocs d'instructions
si jamais vous avez dfini des arguments dans la dclaration de la mthode, il faudra veiller les
inclure lors de l'appel de la mthode (le mme nombre d'arguments spars par des virgules !),
mais sans avoir prciser leur type.
Les arguments d'une mthode

Il est possible de passer des arguments (appels aussi paramtres) une mthode, c'est--dire
lui fournir une valeur ou le nom d'une variable afin que la mthode puisse effectuer des
oprations sur ces arguments ou bien grce ces arguments.
Le passage d'arguments une mthode se fait au moyen d'une liste d'arguments (spars par
des virgules) entre parenthses suivant immdiatement le nom de la mthode.
Le nombre et le type d'arguments dans la dclaration, le prototype et dans l'appel doit

correspondre, au risque, sinon, de gnerer une erreur lors de la compilation...
Un argument peut tre :
une constante
une variable
une expression
une autre mthode retournant une valeur
Renvoi d'un valeur par une mthode

La mthode peut renvoyer une valeur (et donc se terminer) grce au mot-cl return. Lorsque
l'instruction return est rencontre, la mthode value la valeur qui la suit, puis la renvoie au
programme appelant (classe partir de laquelle la mthode a t appele).
Une mthode peut contenir plusieurs instructions return, ce sera toutefois la premire
instruction return rencontre qui provoquera la fin de l'excution de la mthode et le renvoi de
la valeur qui la suit.
40
La syntaxe de l'instruction return est simple :
return valeurDeRetour ;
Le type de valeur retourn doit correspondre celui qui a t

prcis dans la dfinition
La surcharge de mthode
Un des apports les plus intressants de la conception objet, est la possibilit d'appeler
plusieurs mthodes avec le mme nom, condition que leurs arguments diffrent (en type
et/ou en nombre).
Ce principe est appel surcharge de mthode. Il permet de donner le mme nom des
mthodes comportant des paramtres diffrents et simplifie donc l'criture de mthodes
smantiquement similaires sur des paramtres de types diffrents.
En effet, une mthode est dtermine par ce que l'on appelle sa signature, c'est--dire :
sa classe d'appartenance
son nom
ses paramtres
Il est ainsi possible de dfinir une mthode ralisant la mme opration sur des variables
diffrentes en nombre ou en type :
int somme (int p1, int p2) {

return p1+p2 ;
}
int somme (int p1, int p2, int p3) {

return p1+p2+p3 ;
}
double somme (double p1, double p2) {

return p1+p2 ;
}
41
Java - Les objets
La cration d'objets
Un objet est une instance de classe, la cration d'objets se fait l'aide du constructeur de cette
classe. Cette instanciation se fait grce l'oprateur new suivi du nom de la classe instancier
et des parenthses contenant les paramtres du constructeur.
Un exemple avec la classe String :
new String("Bonjour");
Les rfrences
Lorsqu'un objet est construit, les donnes qui le constituent sont places dans un endroit de la
mmoire auquel on ne peut pas directement accder. On peut cependant rcuprer une
rfrence de l'objet, c'est dire le point d'accs en mmoire de cet objet, que l'on place alors
dans une variable.
Le concept des rfrences est trs proche de celui des
pointeurs en langage C/C++, mais leur utilisation est beaucoup
plus transparente pour le dveloppeur.
String str = new String ("Bonjour") ;
Contrairement ce que l'on pourrait penser, la variable str ne contient pas la chane de
caractres "Bonjour", mais uniquement une rfrence (un entier) vers l'objet qui est en
mmoire. Mais il est impossible de modifier les donnes en mmoire autrement qu'en utilisant
les mthodes de l'objet.
Remarque : chaque objet a une seule rfrence, c'est dire une seule adresse en mmoire,
mais on peut avoir plusieurs variables qui possdent la mme rfrence.
String str1, str2, str3 ;

str1 = new String ("Bonjour") ;
str2 = str1 ;
str3 = new String ("Au revoir") ;
Ici str1 et str2 auront la mme valeur, c'est dire la rfrence de l'objet de la classe String
dont les donnes reprsentent le mot "Bonjour". En revanche str3 rfrence un autre objet,
plac ailleurs en mmoire, et dont les donnes reprsentent le mot "Au revoir".
Accder aux donnes membres d'un objet

L'accs aux donnes membres d'un objet se fait grce la rfrence de l'objet (par exemple
via la variable qui contient cette rfrence), suivi d'un point, puis du nom de la donne
membre. Par exemple :
42
reference.nomDonnee = valeur ;
Si la donne membre est elle-mme la rfrence d'un autre objet, alors on peut galement
accder ses donnes membres de la mme manire :
(reference.donneeQuiReference).nomDonnee = valeur
Remarque : les parenthses sont ici totalement inutiles, on peut tout fait les enlever.
Accder aux mthodes d'un objet

L'accs aux mthodes d'un objet se fait comme pour l'accs aux donnes membres, c'est--dire
par un point. La mthode est suivie de parenthses, contenant les paramtres, si il y'en a.
L'accs une fonction membre se fait donc de la faon suivante :
reference.methode (parametre1, parametre2) ;
Le mot cl this
Le mot cl this permet de dsigner l'objet courant. Lorsque l'on dveloppe une classe, on code
le comportement que devra avoir l'objet lorsqu'il sera utilis, si dans une mthode un objet
doit s'utiliser lui-mme (en gnral comme argument d'une autre mthode), alors il est
ncessaire de connatre sa propre rfrence, qui nous a donn par la valeur de this.
Par exemple : dans une mthode on veut que l'objet s'affiche lui-mme l'cran, on pourrait
faire :
public void afficher () {

System.out.println(this);
}
MaClasse monObjet = new MaClasse(mesParametres);

monObjet.afficher();</code>
Ici, l'intrieur de la mthode afficher, la rfrence de this sera exactement celle de
monObjet.
Remarque : il est courant de mlanger les termes d'objet et de rfrence, et ainsi d'appeler
"objet" ce qui est une "rfrence", mais cela a bien souvent peu d'importance.
Par analogie, cette confusion revient demander quelqu'un "d'appeler un numro de
tlphone", or ce n'est jamais un numro de tlphone que l'on appelle, mais la personne qui
est joignable en appelant ce numro de tlphone. Le numro de tlphone serait donc la
rfrence qui permet d'utiliser l'objet (appeler la personne). Pour peu que l'on ait un service
demander cette personne, on caractrise alors la notion de mthode.
43
Java - Constructeurs
Le constructeur : une mthode particulire
Pour instancier une classe, c'est--dire crer un objet partir d'une classe, il s'agit d'utiliser
l'oprateur new.
En ralit l'oprateur new, lorsqu'il est utilis, fait appel une mthode spciale de la classe :
le constructeur.
Le rle du constructeur est de dclarer et de permettre d'initialiser les donnes membres de la

classe, ainsi que de permettre diffrentes actions (dfinies par le concepteur de la classe) lors
de l'instanciation.
Un constructeur se dfinit comme une mthode standard, mais ne renvoie aucune valeur.
Ainsi, le constructeur d'un objet porte le mme nom que la classe et ne possde aucune valeur
de retour (mme pas void).
un constructeur porte le mme nom que la classe dans laquelle il est dfini
un constructeur n'a pas de type de retour (mme pas void)
un constructeur peut avoir des arguments
la dfinition d'un constructeur n'est pas obligatoire lorsqu'il n'est pas ncessaire
La dfinition de cette fonction membre spciale n'est pas obligatoire (si vous ne souhaitez pas
initialiser les donnes membres par exemple) dans la mesure o un constructeur par dfaut
(appel parfois constructeur sans argument) est dfini par le compilateur Java si la classe n'en
possde pas.
Voyons sur un exemple comment se dclare un constructeur :
class Toto{
int age;
char sexe;
float taille;
Toto(int age, char sexe, float taille){

this.age = age;
this.sexe = sexe;
this.taille = taille;
}
}
Dfinir plusieurs constructeurs

Comme pour n'importe quelle mthode, il est possible de surcharger les constructeurs, c'est--
dire dfinir plusieurs constructeurs avec un nombre/type d'arguments diffrents. Ainsi, il sera
possible d'initialiser diffremment un mme objet, selon la mthode de construction utilise.
44
Imaginons par exemple que pour l'exemple prcdent on veuille pouvoir dfinir le sexe de
Toto grce un entier valant 0 ou 1, ainsi qu'avoir la possibilit de passer en paramtre la
lettre 'M' ou 'F', on peut alors dfinir deux constructeurs pour lesquels le type du second
argument sera diffrent. De plus, on va montrer de quelle manire il est possible de contrler
le caractre entr en paramtre :
class Toto{
int age;
char sexe;
float taille;
Toto(int age, char sexe, float taille){

this.age = age;
if ((sexe=='M')||(sexe=='F')) {
this.sexe = sexe;
}
else System.out.println("Erreur d'initialisation");
Toto(int age, int sexe, float taille){

this.age = age;
switch (sexe) {
case 0 :
this.sexe = 'F';
break;
case 1:
this.sexe = 'M';
break;
default :
System.out.println("Erreur d'initialisation");
break;
}
45
Java - L'hritage
La notion d'hritage
Le concept d'hritage est un des concepts les plus importants de la programmation oriente
objet, car il conditionne irrversiblement la faon selon laquelle un code Java est crit.
L'hritage est un mcanisme permettant de crer une nouvelle classe partir d'une classe
existante en lui profrant ses proprits et ses mthodes.
Ainsi, pour dfinir une nouvelle classe, il suffit de la faire hriter d'une classe existante et de
lui ajouter de nouvelles proprits/mthodes.
De cette faon, les classes hrites forment une hirarchie descendante, au sommet de laquelle
se situe la classe de base (superclasse). On appelle galement la classe hrite la sous-classe
et la classe parente la super-classe.
Avec Java, l'arborescence est stricte, c'est--dire qu'une classe donne ne peut possder qu'une
seule superclasse (l'hritage est dit simple contrairement des langages comme le C++, pour
lesquels un hritage dit multiple est possible). Par contre, une classe peut possder un nombre
illimit de sous-classes.
Lors de l'instanciation d'une classe, celle-ci hrite de (cela signifie qu'elle reoit) l'ensemble
des proprits et des mthodes de sa superclasse, qui elle-mme hrite d'une ventuelle
superclasse, etc.
Par consquent le travail principal du programmeur Java consiste concevoir une hirarchie
de classe, c'est--dire organiser les classes de telles faon que les proprits et mthodes
communes plusieurs classes soient places dans une superclasse.
Grce ce systme organisationnel, il est ais de rutiliser des composants existants et de leur
ajouter un comportement. De plus, la modification de la superclasse implique la modification
automatique de toutes les sous-classes. Pour plus d'informations sur l'hritage, consulter la
section "programmation oriente objet"
L'hritage avec Java

Une classe se dfinit tout simplement grce au mot-cl class de la manire suivante par
exemple :
class Ccm {
46
// Corps de la classe
}
Par dfaut une classe hrite de la "super-superclasse" nomme Object. Pour faire hriter une
classe d'une superclasse, Java fournit le mot-cl extends, c'est--dire que les quelques lignes
de code ci-dessus sont quivalentes :
class Ccm extends Object {
// Corps de la classe
}
Le mot-cl super
Au mme titre que le mot-cl this permet de faire rfrence l'objet en cours, le mot-cl super
permet de dsigner la superclasse, c'est--dire qu' l'aide du mot-cl super, il est possible de
manipuler les donnes membres et les mthodes de la superclasse.
Pour manipuler une prorit de la superclasse, il suffit d'utiliser la syntaxe suivante :
super.nom_de_la_propriete
De la mme faon, pour manipuler une mthode de la superclasse, il suffit d'utiliser la syntaxe
suivante :
super.nom_de_la_methode ()
Enfin, il est possible de faire appel au constructeur de la classe parente en fournissant des
arguments au mot-cl super de la faon suivante :
super (parametre1, parametre2,...)
Remplacer une mthode existante de la superclasse

Lorsqu'une classe hrite de sa superclasse, elle hrite de ses mthodes, c'est--dire qu'elle
possde les mmes mthodes que sa superclasse.
Il est possible de redfinir totalement une mthode en la redfinissant (mmes nombres et

types d'arguments que la mthode de la superclasse). De cette faon, la mthode originale est
ignore au profit de sa redfinition.
Ajouter un comportement une mthode de la superclasse

La redfinition d'une mthode consiste rcrire totalement la mthode initiale. Il est parfois
utile de simplement ajouter un comportement au comportement original, pour cela l'utilisation
du mot-cl super s'avre ncessaire. En appelant le constructeur de la superclasse dans le
corps de la mthode qui la redfinit, et en ajoutant de nouvelles instructions, la mthode
originale est dote de comportements supplmentaires.
47
Java - L'accessibilit
La notion d'accessibilit
La protection des donnes membres
Les niveaux d'accs
La notion d'accesseur
La notion de mutateur
La notion d'accessibilit
Le concept d'accessibilit (gnralement appel encapsulation) dfinit la possibilit qu'a le
concepteur d'une classe de restreindre l'accs certaines donnes, ou plus gnralement
certains lments (mthodes, classes, ...).
PUBLICIT
En effet, les classes sont prvues pour tre diffuses (parfois de faon payante) afin de
pouvoir tre rutilises par certains programmeurs. Or il est gnralement souhaitable que les
utilisateurs de la classe se servent de celle-ci de la manire de laquelle le concepteur a prvu
qu'elle le soit. Ainsi, il est possible de restreindre l'accs (ou bien l'instanciation de) certains
lments en leur
associant une tiquette.
La protection des donnes membres

l'encapsulation consiste donc dfinir
des tiquettes pour les donnes membres et les mthodes afin de prciser
si celles-ci sont accessibles partir d'autres classes ou non...
De cette manire, des donnes membres portant l'tiquette private ne peuvent pas tre
manipules directement par les mthodes des autres classes.
Ainsi, pour pouvoir manipuler ces donnes membres, le crateur de la classe (vous en
l'occurrence) doit prvoir des mthodes spciales portant l'tiquette public, permettant de
manipuler ces donnes.
Les fonctions membres permettant d'accder aux donnes membres sont appeles
accesseurs,
parfois getter (appelation d'origine anglophone)
Les fonctions membres permettant de modifier les donnes membres sont appeles
mutateurs, parfois setter (appelation d'origine anglophone)
48
On appelle gnralement "interface" l'ensemble des mthodes permettant l'utilisateur
de manipuler une classe.
Les niveaux d'accs

Java dfinit quatre niveaux d'accs pour les variables d'instances
(donnes membres) et les mthodes :
public : un lment public est accessible
de partout et sans aucune restriction. Certaines classes (comme la classe principale main) doivent
obligatoirement tre dclares publiques (pour pouvoir excuter l'application...)
protected : un lment protected (protg) est accessible uniquement aux classes d'un
package et ses classes filles
private : un lment private (priv) est accessible uniquement au sein de la classe dans
laquelle il est dclar. Ces lments ne peuvent tre manipuls qu' l'aide de mthode
spcifiques appels accesseur et mutateur
"friendly" : un lment est friendly par dfaut (cette appellation n'est pas officielle et est
emprunte
au langage C++) est accessible

uniquement aux classes d'un package.
La notion d'accesseur
Un accesseur est une mthode permettant de rcuprer le contenu d'une donne membre
protge. Un accesseur, pour accomplir sa fonction :
doit avoir comme type de retour le type de la variable renvoyer

ne doit pas ncessairement possder d'arguments
Une convention de nommage veut que l'on fasse commencer de faon prferrentielle le nom de
l'accesseur par le prfixe get, afin de faire ressortir sa fonction premire.
La syntaxe d'un accesseur rduit sa plus simple expression ressemble donc ceci :
public class MaClasse{
public static void main(String[] argv){
new MaSecondeClasse();
}
}
class MaSecondeClasse{
private TypeDeMaVariable maVariable;
public TypeDeMaVariable getMaVariable(){

return maVariable;
}
}
49
Sur l'exemple prcdent, l'accesseur minimal de la donne membre age
pourrait tre le suivant :
class Toto{
private int age;
public int getAge(){

return age;
}
}
La notion de mutateur
Un mutateur est une mthode permettant de modifier le contenu d'une donne membre
protge. Un mutateur, pour accomplir sa fonction :
doit avoir comme paramtre la valeur assigner la donne membre. Le paramtre doit
donc tre du type de la donne membre
ne doit pas ncessairement renvoyer de valeur (il possde dans sa plus simple expression le
type void)
Une convention de nommage veut que l'on fasse commencer de faon prferrentielle le nom du
mutateur par le prfix set.
La syntaxe d'un mutateur rduit sa plus simple expression ressemble donc ceci :
class MaClasse{
private TypeDeMaVariable maVariable;
public void setMaVariable(TypeDeMaVariable maValeur){

maVariable = maValeur;
}
}
Sur l'exemple prcdent, le mutateur minimal de la donne membre age pourrait tre le suivant :
class Toto{
private int age;
public void setAge(int nouveauAge){

age = nouveauAge;
}
}
50
L'intrt principal d'un tel mcanisme est le contrle de la validit des donnes membres qu'il
procure. En effet, il est possible (et mme conseill) de tester la valeur que l'on assigne une
donne membre, c'est--dire que l'on effectue un test de validit de la valeur de l'argument
avant de l'affecter la donne membre.
Le mutateur ci-dessus peut par exemple vrifier si l'ge de Toto est correct
(on considrera pour cela que Toto ne peut pas vivre plus de 200 ans...c'est avec des
hypothses telles que celle-ci que peuvent apparatre des bogues...ah les progrs de la
gntique !).
class Toto{
private int age;
public int setAge(int nouveauAge){

if (nouveauAge < 200) {
age = nouveauAge;
return 1;
}
else return 0;
}
}
51
Java - Les packages
Introduction aux packages
La programmation Java consiste crer des classes. Or, tant donn qu'un programme est
gnralement dvelopp par une quipe de programmeurs, c'est--dire plusieurs personnes, le
fait de concatner (mettre bout bout) des classes dans un fichier est loin d'tre satisfaisant.
C'est pour cette raison que Java propose l'utilisation de packages (comparables aux
bibliothques du langage C++/C)
Ainsi, un package est une unit (un fichier) regroupant des classes. Pour crer un tel package,
il suffit de commencer le fichier source contenant les classes regrouper par l'instruction
package suivi du nom que l'on dsire donner au package. ds lors, toutes les classes contenues
dans le fichier feront partie du package...
L'organisation hirarchique
Les packages sont organiss sous forme de hirarchie, c'est--dire qu'il est possible de les
imbriquer, pour cela Java impose que l'emplacement des fichiers sources (donc des packages)
correspondent la hirarchie des packages, c'est pour cela qu'un package portant le nom
MonPackage doit tre stock dans un rpertoire du mme nom. De plus, pour que le
compilateur puisse trouver le package, il est essentiel qu'il "connaisse" l'emplacement du
package. Pour cela Java utilise une variable d'environnement (dans le mme ordre d'ide que
la variable d'environnement PATH) appele classpath donnant la liste des chemins d'accs
aux classes.
Par dfaut le compilateur (ainsi que la machine virtuelle) recherchent les classes dans le
rpertoire courant et le rpertoire des classes standards.
Pour dfinir la variable d'environnement classpath
sous Linux, il faut utiliser la commande suivante :
export</i> CLASSPATH = <repertoire>:<repertoire>;...
par exemple :
export CLASSPATH = /home/jeff/java:/usr/lib/jdkx.x.x/lib/classes.zip:...
sous Windows, il faut utiliser la commande suivante :
SET CLASSPATH = <repertoire>;<repertoire>;...
par exemple :
SET CLASSPATH = c:\java;c:\jdkx.x.x\lib\classes.zip;...
L'instruction import
52
Pour pouvoir accder aux classes d'un package partir d'une classe ne faisant pas partie du
package, il suffit de donner le chemin d'accs relatif la classe lorsque vous fates appel
elle. Ainsi, pour faire appel la classe MaClasse du package MonPackage, il suffit d'crire :
MonPackage.MaClasse
Toutefois il s'avre vite embarrassant d'avoir crire constamment le chemin d'une classe,
ainsi il est gnralement pratique d'utiliser l'instruction import, suivie du chemin de la classe :
import MonPackage.MaClasse;
Il est galement possible d'importer toutes les classes d'un package par la syntaxe :
import MonPackage.*;
Voil ce quoi ressemble une application Java utilisant des packages (c'est--dire tous ou presque
car vous aurez utiliser des packages fournis avec le JDK) :
import java.awt.Button; // On importe la classe Button
import java.rmi.*; // On importe toutes les classes RMI
class Exemple {
static void main(String argv[]){
Rect MonRect =new Rectangle();
...
}
}
Contrairement ce que l'on pourrait croire, l'instruction import

MonPackage.*; permet de rendre accessible uniquement les classes contenues
dans le package MonPackage et non l'ensemble des packages dont le nom
commence par MonPackage, c'est--dire que la classe
MonPackage.pack1.MaClasse ne sera pas accessible...
Convention de dnomination des packages

tant donn la structure hirarchique des packages et le nombre considrables de packages
crs par des dveloppeurs du monde entier, il est essentiel d'viter de donner le mme nom
des packages diffrents.
Ainsi Java propose une dnomination standard des packages. Cette appellation standard
consiste donner un nom au package et de "l'allonger" par le nom de la socit, ou du
concepteur des classes qu'il contient. Ainsi, un package soundstuffs dvelopp par CCM
aurait pour dnomination net.commentcamarche.soundstuffs.
Packages et accessibilit
L'accessibilit des donnes membres et des mthodes d'une classe existe aussi au travers des
packages. Ainsi, une classe n'est par dfaut visible qu' partir des classes faisant partie du
mme package. Or l'intrt d'un package est justement de pouvoir tre utilis partir de
classes dclares dans un autre fichier, c'est la raison pour laquelle les classes d'un package
destines tre exportes doivent imprativement tre dclares publiques...
53
Packages accessibles par dfaut
Java dfinit deux packages par dfaut, c'est--dire un ensemble de classes auxquel il est
possible de faire rfrence sans spcifier le chemin d'accs (que ce soit avec une instruction
import ou en faisant prcder le nom par la hirarchie de packages). Ces packages sont :
Le package par dfaut: il s'agit de toutes les classes ne faisant pas partie explicitement d'un
package et situes dans les rpertoires accessibles (par dfaut ou dans la variable classpath)
Le package java.lang contenant les classes standards telles que System ou Math
Les fichiers .jar

Avec la croissance des rseaux, les applications sont voues voyager, il faut donc s'assurer :
qu'elles restent intactes

que tous les lments (packages) de l'application sont prsents
de rendre l'application la moins gourmande en espace
Ainsi, Java propose l'utilitaire jar dans le JDK, un utilitaire permettant de rassembler les diffrentes
classes (fichiers .class) d'une application au sein d'une archive compresse, appel package, afin d'en
assurer l'intgrit et la taille.
Grce cet utilitaire, il est possible d'appeler partir d'une page Web l'ensemble des classes
d'une applet en faisant uniquement rfrence l'archive (dont l'extension est .jar).
La syntaxe de jar est proche de celle de tar sous Unix :
Pour crer l'archive la commande est la suivante :
jar cvf MonArchive.jar *.class
Pour dcompresser l'archive la commande est :
jar xvf MonArchive.jar *.class
Lorsque vous utilisez une archive Jar sur Internet, toutes les classes de celle-ci seront
tlcharges en mme temps, veillez donc y inclure uniquement les classes ncessaires
pour une application donne
L'utilitaire MoaJar permet de manipuler les archives Jar l'aide d'une interface graphique
54
Java - Les exceptions
La ncessit de dtecter les erreurs
Tout programme comporte des erreurs, mme si celui-ci semble fonctionner merveille.
Chaque programmeur essaye de rduire au minimum le nombre d'erreurs, mais toutes les
erreurs ne peuvent pas forcment tre prvues.
Les erreurs syntaxiques sont la plupart interceptes lors de la compilation, mais il reste
souvent des erreurs "imprvisibles".
Ces erreurs se produisent gnralement de faon exceptionnelle, c'est--dire suite une
action de l'utilisateur, ou de l'environnement. La solution consiste donc dans un premier temps
"prvoir les erreurs imprvisibles" en mettant en place un systme de codes d'erreurs, c'est-
-dire un systme permettant de retourner des valeurs spcifiques pour signaler un
fonctionnement anormal de l'application (souvent -1 ou NULL).
Toutefois cette solution est loin d'tre satisfaisante car :
elle rend difficile l'criture de programmes

elle rend difficile la lecture du code source, cause d'une embrication de test conditionnels
(if .. else)
le code d'erreur retourne peut-tre confondue avec la valeur retourne par la fonction... (-1
peut trs bien tre la valeur de retour d'une fonction)
La notion d'exception
Pour traiter les erreurs, Java propose un mcanisme qualifi d'exception, consistant effectuer
les instructions dans un bloc d'essai (le bloc try) qui surveille les instructions. Lors de
l'apparition d'une erreur, celle-ci est </ital>lance</ital> dans un bloc de traitement d'erreur
(le bloc catch, appel handler d'exception) sous forme d'un objet appel Exception.
Le bloc de traitement d'erreur va lever (il s'agit du terme technique, certains diront aussi
intercepter) l'exception. Le handler d'exception peut alors traiter l'erreur (en signalant l'erreur
par exemple, ou en attendant avant de ressayer, ...) puis lancer nouveau l'exception vers un
bloc de plus haut niveau.
55
Il est important de souligner que la transmission des
exceptions est d'abord *implicite*. C'est bien videmment pour
cette raison que le concept d'exception est un rel progrs
pour l'criture d'un code facile lire.
Les exceptions par la pratique

La gestion des exceptions avec Java consiste dfinir au sein d'une mthode une clause
"try{}" contenant les instructions qui risquent de provoquer une exception et de la faire suivre
immdiatement par une clause "catch{}" contenant comme paramtre l'exception attendue
prcde de son type (pour une erreur mathmatique ce sera ArithmeticException) et dont le
contenu sera une liste d'instruction excuter lorsque l'exception se produira.
Voici la syntaxe type d'une classe grant des exceptions :
class Nom_de_la_classe {
// Instructions inoffensives (affectations, ...);
try {
// Instructions susceptibles de provoquer des erreurs;
}
catch (TypeException e) {
// Instructions de traitement de l'erreur;
}
// Instructions si aucune erreur est apparue;
}
}
Aucune instruction ne doit se trouver entre le bloc try{} et le bloc catch{}

Les blocs try{} et catch{} peuvent chacun contenir plusieurs instructions</ital>
Comment les exceptions sont-elles traites ?

Lorsque le programme rencontre une exception dans un bloc try{}, une exception est
instancie puis lance. L'interprteur cherche un bloc catch(){} partir de l'endroit o
l'exception a t cre en cherchant vers le bas. S'il ne trouve aucun bloc catch{}, l'exception
est lance dans le bloc de niveau suprieur, ainsi de suite jusqu'au bloc de la classe qui par
dfaut enverra l'exception au handler de l'interprteur. Celui-ci mettra alors un message
d'alerte standard pour le type d'exception.
Si jamais un bloc catch{} est trouv, celui-ci grera l'exception sa faon (ou plutt la
votre) et l'exception ne sera pas envoye au handler de l'interprteur.
Si par contre on dsire que l'exception soit trait par les blocs de niveaux suprieurs, il suffit
d'inclure la fin de la srie d'instructions contenues dans le bloc catch{} une clause throw,
suivie du type de l'exception entre parenthse puis du nom de l'exception (son handle pour
utiliser un terme exact). Ainsi l'exception continuera son chemin...
56
class Nom_de_la_classe {
// Instructions inoffensives (affectations, ...);
try {
// Instructions susceptibles de provoquer des erreurs;
}
catch (TypeException e) {
// Instructions de traitement de l'erreur;
throw (TypeException)e;
}
// Instructions si aucune erreur est apparue;
}
}
57
Java - L'API JDBC
Posez votre question
Dcembre 2016
Introduction JDBC
L'accs aux bases de donnes avec JDBC
Les types de pilotes JDBC
La technologie ODBC
La passerelle JDBC-ODBC
Connexion la base de donnes
Connexion la base de donnes
Excution d'une requte SQL
Accs aux donnes
Cration d'objets JDBC de plus haut niveau
Introduction JDBC
La technologie JDBC (Java DataBase Connectivity) est un ensemble de classes permettant de
dvelopper des applications capables de se connecter des serveurs de bases de donnes
(SGBD).
L'accs aux bases de donnes avec JDBC

Dans un systme client/serveur, l'accs aux bases de donnes avec JDBC peut s'effectuer
selon un modle deux couches ou bien un modle trois couches.
Pour le modle deux couches, une application Java est intimement lie avec une base de
donnes. A cet effet, il faut bien videmment disposer, pour la base de donnes concerne,
d'un pilote JDBC adquat. Les instructions SQL sont directement envoyes la base, cette
dernire renvoyant les rsultats par un biais tout aussi direct. La base de donnes peut tre
excute sur la machine locale (celle sur laquelle l'application Java fonctionne) ou bien sur
tout autre ordinateur du rseau (Intranet ou Internet).
PUBLICIT
58
Dans le modle 3 couches, une troisime couche (le serveur d'application) vient s'intercaler entre
l'application Java et la base de donnes. Les instructions SQL et les rsultats livrs en retour y
transitent. Ce modle prsente l'avantage d'intgrer dans cette couche un contrle d'accs.
Les types de pilotes JDBC

Les pilotes actuels sont classs en quatre catgories :
les passerelles JDBC-ODBC, avec le pilote ODBC appartenant une base de donnes. Le pilote
convertit les appels de donnes Java en appel ODBC valide, et les excute ensuite l'aide du
pilote ODBC
un mlange de pilotes natifs et de pilotes Java. Les appels JDBC sont convertis en appels
natifs pour le serveur de bases de donnes (Oracle, Sybase, ou autres).
les pilotes convertissant les appels JDBC en un protocole indpendant du SGBD. Un serveur
convertit ensuite ceux-ci dans le protocole SGBD requis (modle 3 couches)
les pilotes JDBC, convertissant les appels JDBC directement en un protocole rseau exploit
par le SGBD. Cette solution est prconiser dans le cadre d'un intranet
59
A l'heure actuelle, les bases de donnes disposent pratiquement toutes d'un pilote ODBC,
tant donn que nombre d'entre-elles ont t dveloppes partir d'interfaces Microsoft.
La technologie ODBC
ODBC signifie Open Database Connectivity. Il s'agit d'un format propritaire dfini par Microsoft
permettant la communication entre des clients pour bases de donnes fonctionnant sous Windows
et les SGBD du march.
Etant donn qu'il existe diffrents types de bases de donnes, et que chacune d'entre-elles
possde sa propre faon de traiter les requtes SQL et de renvoyer les rsultats, ODBC permet
d'obtenir des rsultats identiques quel que soit le type de base de donnes, sans avoir
modifier le programme d'appel qui transmet la requte.
ODBC n'est toutefois pas la solution miracle, tant donn d'une part qu'il ne s'agit
pas d'une technologie libre (Microsoft la fait voluer son gr), d'autre part qu'il ne s'agit que
d'une interface "alternative" celle fournie par les constructeurs et complique matriser.
La passerelle JDBC-ODBC
Afin d'illustrer la connexion une base de donnes, nous allons nous connecter
une base Access par l'intermdiaire de la passerelle ODBC-JDBC, en abordant toutes
les tapes de la connexion une base de donnes.
Aprs cration de la base sous Access, il faut dans un premier temps intgrer
la base dans l'administrateur de source de donnes ODBC (Panneau de configuration / source
de donnes ).
Les tapes de cration de la source ODBC sont :
la slection du pilote pour la base de donnes concerne (dans notre cas le pilote Microsoft
Access Driver)
la dfinition du nom de la base et de son chemin d'accs
la dfinition du nom de la source de donnes et du mot de passe
Connexio la base de donnes

L'API (Application Programming Interface) JDBC, c'est--dire la bibliothque de classes
JDBC, se charge de trois tapes indispensables la connexion une base de donnes :
la cation d'une connexion la base

l'envoi d'instructions SQL
l'exploitation des rsultats provenant de la base
Connexio la base de donnes
60
Tous les objets et les mthodes relatifs aux bases de donnes sont prsentes dans le package
java.sql, il est donc indispensable d'importer java.sql.* dans tout programme se servant de la
technologie JDBC.
Pour se connecter une base de donnes dclare dans l'administrateur ODBC, il est essentiel
de charger dans un premier temps le pilote JDBC-ODBC (appel pont JDBC-ODBC) :
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Cette instruction charge le pilote et cre une instance de cette classe. Pour se connecter une base
de donnes particulire, il s'agit ensuite de crer une instance de la classe Connection en indiquant la
base de donnes charger l'aide de son URL
String url = "jdbc:odbc:base_de_donnees";
Connection con = DriverManager.getConnection(url);
Le nom de la base de donnes (ici base_de_donnees) tant celle dclare dans le panneau de
configuration ODBC. La syntaxe de l'URL peut varier lgrement selon le type de la base de donnes.
Il s'agit gnralement d'une adresse de la forme :
jdbc:sousprotocole:nom
Excution d'une requte SQL

Pour excuter une requte SQL, il s'agit dans un premier temps de crer un objet Statement,
pouvant tre obtenu partir de l'objet Connection. Un objet ResultSet permettra de rcuprer
les donnes en provenance de l'objet Statement.
String query = "SELECT * FROM Ma_Table;";
ResultSet results;
try {
Statement stmt = con.createStatement();
results = stmt.executeQuery(query);
catch(Exception e){
System.out.println("exception du a la requete");
Accs aux donnes

Une fois la connexion la base de donnes tablie, il est possible de demander des
informations sur le nom des tables et le contenu de chaque colonne, ainsi que d'excuter des
61
requtes SQL afin de rcuprer des informations, d'en ajouter ou bien de les modifier.
Les objets utilisables pour obtenir des informations sur la base sont :
DataBaseMetaData: Un objet contenant les informations sur la base de donnes en gnral

(des mtadonnes), c'est--dire le nom de la table,
les index, la version de la base, ...
ResultSet: Un objet contenant les informations sur une table ou le rsultat
d'une requte. L'accs aux donnes se fait colonne par colonne, mais il est ventuellement possible
d'accder indpendamment chaque colonne par son nom
ResultSetMetaData: Un objet contenant des informations sur le nom et le type des colonnes
d'une table
A chacun de ces objets est associ un grand nombre de mthodes permettant d'obtenir des
informations trs dtailles sur les lments de la base de donnes.
Toutefois, seul un nombre rduit des mthodes de chacun de ces objets permet
d'obtenir les informations les plus importantes sur les donnes.
L'objet ResultSet est l'objet le plus important de la technologie JDBC, car il s'agit d'une
abstraction de la table ou de la rponse une requte (gnralement un sous-ensemble d'une
table). Ainsi, presque toutes les mthodes et requtes retournent les donnes sous forme d'un
62
objet ResultSet. Cet objet contient un nombre donn de colonnes repres chacune par un
nom, ainsi qu'une ou plusieurs lignes contenant les donnes, et auxquelles il est possible
d'accder squentiellement une une du haut vers le bas. Ainsi, afin d'exploiter un objet
ResultSet, il est ncessaire de rcuprer le nombre de colonnes de celui-ci, l'aide de l'objet
ResultSetMetaData.
ResultSetMetaData rsmd;
rsmd = results.getMetaData();
numcols = rsmd.getColumnCount();
Lors de l'obtention d'un objet ResultSet, le descripteur pointe avant la premire ligne.
La mthode next() permet d'obtenir chacune des lignes suivantes, et retourne false lorsqu'il ne
reste plus aucune ligne. Etant donn que l'extraction de donnes de la base peut gnrer des
erreurs, il est indispensable d'inclure ces manipulations dans un bloc d'exception (try).
Les donnes contenues dans le ResultSet peuvent tre obtenues sous

diffrentes formes selon le type de donnes stockes dans chaque colonne. Le contenu de
chaque colonne peut tre obtenu soit par le nom de celle-ci, soit par son numro (sachant que
les numros de colonne commencent 1 et non 0).
Les principales mthodes de l'objet ResultSet sont les suivantes :
getInt(int): rcupre sous forme d'entier le contenu d'une colonne dsigne par son numro
getInt(String): rcupre sous forme d'entier le contenu d'une colonne dsigne par son nom
getFloat(int): rcupre sous forme de flottant le contenu d'une colonne dsigne par son
numro
getFloat(String): rcupre sous forme de flottant le contenu d'une colonne dsigne par son
nom
next(): dplace le pointeur de ligne sur la ligne suivante
close(): "ferme" l'objet
getMetaData(): retourne les mtadonnes de l'objet (l'objet ResultSetMetaData)
L'objet ResultSetMetaData (obtenu de l'objet ResultSet) permet de connatre le nombre, le

nom et le type de chaque colonne l'aide des mthodes suivantes :
getColumnCount(): rcupre le nombre de colonnes

getColumnName(int): rcupre le nom de la colonne spcifie
getColumnLabel(int): rcupre le label de la colonne spcifie
getColumnType(int): rcupre le type de donnes de la colonne spcifie
63
L'objet DataBaseMetaData permet d'obtenir des informations sur la base de donnes entire. Il sert
notamment rcuprer le nom des tables contenues dans la base de donnes. De plus, tant donn
que de nombreuses bases de donnes supportent des variantes du langage SQL, il existe de
nombreuses mthodes associes l'objet DataBaseMetaData permettant de connatre les mthodes
SQL supportes par la base.
Cration d'objets JDBC de plus haut niveau

Puisque l'accs une base de donnes ncessite l'utilisation conjointe de plusieurs objets, il
peut tre intressant de crer quelques objets de plus haut niveau encapsulant la plupart des
comportements cits ci-dessus.
Ainsi la cration d'un objet DataBase pour permettre d'encapsuler

l'ensemble des objets ncessaires la connexion une base de donnes
(Connection, Statement, DataBaseMetaData), ainsi que de (re)dfinir des mthodes simples
permettant de rendre plus simples certaines oprations, comme la cration de la connexion, la
rcupration du nom des tables, ainsi
qu'une mthode Execute rendant l'excution de requte triviale.
class Database
{
Connection con;
resultSet results;
ResultSetMetaData rsmd;
DatabaseMetaData dm;
String catalog;
String types[];
//----------------------------
public Database(String Driver)
{
types = new String[1];
types[0] = "TABLES";
try {
Class.forName(driver);
}
catch(Exception e){
System.out.println("Erreur lors du chargement du driver:"+
e.getMessage());
}
}
//------------------------------------------------------
public void Open(String url,String login,String password)
{
64
try{
con = DriverManager.getConnection(url,login,password);
dma = con.getMetaData();
results = new resultSet(dma.getCatalogs());
String s[];
while(results.hasMoreElements()) {
s = results.NetxElement();
}
}
catch(Exception e){
System.out.println("echec d'ouverture:"+e.getMessage());
}
}
//-----------------
public void Close()
{
try{
con.close();
}
catch(Exception e){
System.out.println("echec lors de la fermeture:"+e.getMessage());
}
}
//-----------------------------
public String[] getTableNames()
{
String[] tbnames = null;
Vector tname = new Vector();
try{
results = new resultSet(dma.getTables(catalog,null,"%",types));
while (results.hasMoreElements())
tname.addElement(results.getColumnValue("TABLE_NAME"));
}
catch(Exception e){
System.out.println(e.getMessage());
}
tbnames = new String[tname.size()];
for(int i=0;i<tname.size();i++)
tbnames[i] = (String)tname.elementAt(i);
return tbnames;
65
//--------------------------------
public String[] getTableMetaData()
{
results = null;
try{
results = new resultSet(dma.getTables(catalog,null,"%",types));
}
catch(Exception e){
}
return results.getMetaData();
//------------------------------------------------
public String[] getColumnMetaData(String tablename)
{
results = null;
try{
results = new resultSet(dma.getTables(catalog,null,tablename,null));
}
catch(Exception e){
}
return results.getMetaData();
//------------------------------------------------
public String[] getColumnNames(String table)
{
String[] tbnames = null;
Vector tname = new Vector();
try{
results = new resultSet(dma.getTables(catalog,null,table,null));
while (results.hasMoreElements())
tname.addElement(results.getColumnValue("COLUMN_NAME"));
}
catch(Exception e){
}
tbnames = new String[tname.size()];
for(int i=0;i<tname.size();i++)
tbnames[i] = (String)tname.elementAt(i);
return tbnames;
66
}
//------------------------------------------------
public void getColumnValue(String table, String columnName)
{
try{
if (table.length()>0)
results = Execute("Select "+columnName+" from "+table+" order by
"+columnName);
}
catch(Exception e){
System.out.println("Erreur sur la valeur de la colonne "
+columnName+e.getMessage());
}
}
//------------------------------------------------
public String getNextValue(String columnName)
{
String res = "";
try{
if (results.hasMoreElements())
res = results.getColumnvalue(columnName);
}
catch(Exception e){
System.out.println("Erreur sur la valeur suivante
"+columnName+e.getMessage());
}
return res;
}
//------------------------------------------------
public resultSet Execute(String sql)
{
results = null;
try{
Statement stmt = con.createStatement();
results = new resultSet(stmt.executeQuery(sql));
}
catch(Exception e){
}
return results;
De la mme faon, un nouvel objet resultSet (avec un r minuscule) peut tre intressant s'il
permet de faon transparente de retourner automatiquement les rsultats sous forme d'un
tableau de valeurs, ainsi qu'en encapsulant le nombre et le nom des colonnes contenues dans
l'objet resultSet...
67

Java Les Wikis

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Java Les Wikis

Transféré par

Droits d'auteur :

Formats disponibles

Java

Comparaison de Java et de C++

La libration de mmoire est transparente pour l'utilisateur (grce un ramasse-

Les versions de Java

public class Nom_du_programme {

Les applets (prononcez Applettes, et traduisez Appliquettes, le nom grotesque donn en

public class Nom_de_l_applet extends java.applet.Applet {

Il y a toutefois quelques rgles respecter :

Les commentaires peuvent tre placs n'importe o dans le fichier source

// Voici un autre commentaire !

javac: le compilateur Java

javac s'utilise avec la syntaxe suivante :

javac <options> <fichiers java>

Une vingtaine d'options sont disponibles, parmi elles :

Premier programme avec Java

/** Votre premier programme Java */

Il ne faut pas spcifier l'extension (.class) au risque d'obtenir

Si il y a plusieurs arguments, ceux-ci doivent tre spars par un

/** Votre premier programme Java */

public static void main (String[] args){

*Une application Java est une classe munie d'une mthode

Premire applet avec Java

Voici donc le code d'une applet toute simple :

public class FirstApplet extends java.applet.Applet {

soit utiliser votre navigateur en ouvrant le fichier HTML

Voyons ligne par ligne comment est constitu cette applet :

public class FirstApplet extends java.applet.Applet {

public void init (){

correspond au corps de la mthode init(). Il s'agit de l'appel de la mthode add(), possdant un

Les types primitifs

Voici un tableau rpertoriant les huit types primitifs du langage Java :

Type Signification Taille (en octets) Plage de valeurs acceptes

Les enveloppeurs (Wrappers)

Voici la liste des enveloppeurs de chaque type primitif Java :

Enveloppeur Type primitif

Nombre entier (byte, short, int, long)

Nombre virgule (float, double)

un entier dcimal : 895

Les nombres de type float sont cods sur 32 bits dont :

23 bits pour la mantisse

Les nombres de typedouble sont cods sur 64 bits dont :

52 bits pour la mantisse

de 6 chiffres significatifs pour le type float

Chanes de caractres (String)

Conversion de type de donnes (casting)

conversion implicite : une conversion implicite consiste en une modification du type de

inRead invented by Teads

Nom de variable correct Nom de variable incorrect Raison

Une variable se dclare de la faon suivante :

Ou bien s'il y a plusieurs variables du mme type :

Affectation d'une donne une variable

Pour cela on utilise l'oprateur d'affectation "=" :

Il est aussi possible d'initialiser les valeurs lors de leurs dclarations.

char caractere = 'B';

Porte (visibilit) des variables

final int MA_CONSTANTE = 12

les oprateurs de calcul

Les oprateurs de calcul

Oprateur Dnomination Effet Exemple Rsultat (int

Les oprateurs d'assignation

Les autres oprateurs du mme type sont les suivants :

Les oprateurs d'incrmentation

Oprateur Dnomination Effet Syntaxe Rsultat (int x=7)

Exemples (pour x=7)