Cours Java Mit Sylla

8/18/2019 Cours Java Mit Sylla

1/133

COURS DE PROGRAMMATION

ORIENTÉE OBJET

JAVA

Mr SYLLA. Ingenieur en informatique 1


2/133

Plan du Cours• Chapitre 1 : Introduction à Java

• Chapitre 2 : Techniques de base du langage• Chapitre 3 : Les types primitifs


• Chapitre 5 : Programmation Orientée Objet• Chapitre 6 : Les tableaux

• Chapitre 7: Les chaînes de caractères


3/133

Plan du cours (fin)

• Chapitre 8 : L’héritage• Chapitre 9 : Gestion des exceptions•

Mr SYLLA. Ingenieur en informatique3

• Chapitre 11: Les Swing GUI• Chapitre 12 : Entrées Sorties

• Chapitre 13: Collections et algorithmes• Chapitre 14 : Applets• Chapitre 15 : JDBC


4/133

istorique !"rigines de #a$a% 1&&'

Internet trs *eu connu+ ,orld ,ide ,e- ineistant . -oom des PCs (*uissance)

Chapitre 1 Introduction à Java


% Langage *our la communication des a**areils 5lectroniques .% 1&&3 mars ! le CSA lance M"SAIC+ le *remier na$igateur internet

(*rotocole 6tt*+ langage 6tml)+ le 7e- d5colle... 5t5 ! "a0 c6ange d8orientation et s8ada*te 9 la tec6nologie internet

% 1&&: mai 1&&: ! *ro/et ot#a$a++ na$igateur ,;


5/133

Plusieurs langages de *rogrammation ont $u le /our !

Langage mac6ine

Spécifique aux UAL

Les générations des langages de programmation

Mr SYLLA. Ingenieur en informatique :

Langage assem eur

Langage algorit6mique

Langage orient5 o-/et

C pascalco!ol "

C## smalltal$ %ava&'()*A+ILI*, -.(LU*I+I*-& /IA+ILI*, )-U*ISA+ILI*-


6/133

Imprégné du C## mais améliorant ses insuffisances&2 gestion automatique de la mémoire 3ar!age Collector4&2 facilité de stoc$age des fichiers sur disque sérialisation4

Une gigantesque A'I Application 'rogramming Interface4

Java 5 un langage o!%et

Mr SYLLA. Ingenieur en informatique =

& une ra r e e c asses tr s mportante nter ace grap queréseau 6e! !ase de données "4& porta!ilité sans mesure& langage de plus en plus utilisé et évoluant rapidement7


7/133

Interprétation Compilation Interprétation 8 Compilation

'rogramme écrit en 9 'rogramme écrit en 9 'rogramme écrit en 9

'rogramme interprété et compilé

Mr SYLLA. Ingenieur en informatique >

Interpréteur de 9 Compilateur de 9en langage machine

Compilateur de 9 en : plus proche du langage

;achine4

'rogramme enLangage de :

Interpréteur de :

'rogramme en langagemachine


8/133

""77

""7

77777"

""77

""

""

Code

sourcecotédéveloppeur

La ;achine .irtuelle %ava J.;4

Mr SYLLA. Ingenieur en informatique ?

%ava&compiler %avac4

Interprétation par la;achine virtuelle Java pour

lesS


9/133

'rogrammation structurée Constitué

'rocédures

Structuresde données

La 'rogrammation (rientée (!%et '7(7(4

Mr SYLLA. Ingenieur en informatique &

'rogrammation o!%et Constituéo!%ets

Champs données4

;éthodes

des procédures4


10/133

Le concept de classe correspond simplement à la

généralisation de type que l’on rencontre dans les langages

Concept de classe

Mr SYLLA. Ingenieur en informatique 1'

classiques. En effet, une classe n’est rien d’autre que la

description d’un ensemble d’objets ayant une structure de

données commune et disposant des mêmes méthodes.

Les objets apparaissent alors comme des variables d’un

tel type classe (en P.O.O, on dit aussi qu’un objet est une

instance de sa classe ).Bien entendu, seule la structure estcommune , les valeurs des champs étant propres à chaque

objet. En revanche, les méthodes sont communes à l’ensemble

des objets d’une même classe.


11/133

La '7(7( 5l= encapsulation


'rincipe d=encapsulationdes données

respect du

Impossi!led=agir

directementsur les

données


12/133

• Le JRE contient uniquement l'environnement d'exécution de programmes Java. Le JDK

contient lui même le JRE. Le JRE seul doit être installé sur les machines ou desapplications java doivent être exécutées.• Depuis sa version 1.2, Java a été renommé Java 2. Les numéros de versions 1.2 et 2

désignent donc la même version.• Le JDK a été renommé J2SDK (Java 2 Software Development Kit) mais la

J)- Java )untime -nvironnment4


, ,

Interpreteur) utilisée.• Le JRE a été renommé J2RE (Java 2 Runtime Édition).• Trois éditions de Java existent :• J2ME : Java 2 Micro Édition ·• J2SE : Java 2 Standard Édition ·• J2EE : Java 2 Entreprise Édition ·• Sun fourni le JDK, à partir de la version 1.2, sous les plate−formes Windows, Solaris et

Linux.


13/133

J@;- Java@ ;icro ,dition4

& Applications sur environnement

limité& s


14/133

L= A'ILBA.P.I. (A**lication Programming Interface) est un ensem-le de classes etinterfaces *r5d5finies utilisa-les *ar le *rogrammeur 7;lles sont *r5sent5esdans des *ac0ages (/a$a.lang+ /a$a.mat6+ /a$a.util+ etc..

n *rogramme #AA est constitu5 dBun certain nom-re de classes !@ des classes *r5d5finies de lBAPI (en$iron un millier de classes)


** ca on rogramm ng n er ace .

@ des classes d5finies *ar lButilisateur

classes définiespour ce

programme

A'I

PD"EDAMM;classe ! t*e dedonn5es

F fonctions *ourles mani*ulerUn programme utiliseau maximum

les fonctionnalit5spr5sentes dans lBA7'7I7


15/133

Application standalone et Application -+

Les a**lications rentrent g5n5ralement dans le cadre desa**lications standalone ou des a**lications 7e- destin5es 9 l8internet. Les a**lications autonomes sont des *rogrammes

e5cut5s sous le contrGle du sstme

Mr SYLLA. Ingenieur en informatique 1:

dBe*loitation.Les *rogrammes C+ CFF H sont des a**lications dece t*e.

Les a**lications 7e- sont e5cut5es lors de la$isualisation *ar un na$igateur ,;< dBune *ageML. ;n g5n5ral elles sont 65-erg5es *ar desser$eurs 7e- comme A*ac6e omcat. ;lles sont

trs r5*andues a$ec la tec6nologie #;;.

A**lication Standalone

A**lication ,;<


16/133

Applications 5la console vs 37U7I

L8utilisateur fournit des infos au cla$iersous forme de lignes de tete. Le*rogramme d5cide du s5quencementdes o*5rations. L8o*5rateur est sollicit5

'rogramme 9 interfaceconsole

Mr SYLLA. Ingenieur en informatique 1=

au moment $oulu.

L8interaction *rogramme@o*5rateur sefait essentiellement $ia des com*osants

gra*6iques. C8est la *rogrammation5$nementielle !le *rogramme r5agit 9des 5$nements *ro$oqu5s *ar l8utilisa@teur.

'rogramme 9 interfacegraphique 5 3UI

3raphical User Interface4

JI K CAPID;


17/133

Chapitre @ *echniques de !ase du langage

Premier *rogramma #a$a.

*ac0age 6ome.user./a$a.essai un *remier *rogrammeN

Ceci est un commentaire finissant en fin de ligne

Mr SYLLA. Ingenieur en informatique 1>

ello ,orldN*u-lic class ello,orld O

*u-lic static $oid main(String Q args) O

Sstem.out.*rintln(Rello ,orld R)TT

N ceci est un commentaires *ou$ant encadrerun nom-re quelconques de caractressur un nom-re quelconque de lignes N

ello ,orld


18/133

Structure du programme 1D@4

*ac0age 6ome.user./a$a.essai

Mr SYLLA. Ingenieur en informatique 1?

O*u-lic static $oid main(String Q args)

OSstem.out.*rintln(Rello ,orld R)

TT

K5finition de la classea$ec une seule m5t6ode(la m5t6ode main)


19/133

Structure du programme @D@4

Le mot cl5 static *r5cise que la m5t6ode main n8est *as li5e 9 une instance (o-/et)*articulire de la classe. Le *aramtre String Q args est un ta-leau de c6aVnes de caractres qui *ermet der5cu*5rer des arguments transmis au *rogramme au moment de son lancement.Ce aramtre est "


20/133


21/133

Contenu du programme

Le *rogramme est constitu5 d8une seule instruction !S


22/133

-xécution du programme 1D@4

La sau$egarde du *rogramme se fait im*5rati$ement dans un fic6ier qui*orte le nom ello,orld./a$a

nom de la classeetension


Le code source d8une classe *u-lique doit tou/ours se trou$er dans unfic6ier *ortant le mUme nom et *oss5dant l8 etension ./a$a.

La classe contenant la m5t6ode main est a**el5e la classe *rinci*ale

du *rogramme. C8est cette classe qu8il faut e5cuter. ; JAI " ;;C;Z; L;S ISDCI"S K; LA M;"K; main.


23/133

-xécution du programme @D@4

"n *rocde 9 la C"MPILAI" de ce *rogramme *our la g5n5ration du -te code.

Si elle se *asse -ien( sans erreurs) on o-tient un fic6ier d8etension .class . Ici+ il s8agitde ello,orld.class .


a$ac ello,orld./a$a ello,orld.class

Commande /a$ac *our com*iler le source

etension indis*ensa-le

/a$a ello,orld

Commande /a$a *our e5cuter le -tecode

aucune etension ne doit figurer

A;I"! en *ratique+ on tiendra tou/ours com*te des $aria-les d8en$ironnementPA et CLASSPA (cf. dia*os sui$antes).


24/133

Les commandes de !ase du langage

/a$ac ! *our la com*ilation ( g5n5rer le .class). /a$a ! *our l8e5cution ( du main).


! .

/a$adoc ! *our g5n5rer une documentationautomatique.


25/133

Catégories d=instructions

*ac0age info.fst.slla.*ro

*u-lic class *esInstructionsO *u-lic static $oid main(String args Q )

S stem.out. rint Rinstruction sim leR Instruction sim*le termin5e


int i [ 'if ( i \ 1''')Sstem.out.*rint(Rinstruction de structuration R)

static O int ta- Q [ ne7 int12Q

for (i [ 'i ] ta-.lengt6 iFF)ta-iQ [ i F1'T

T

*ar un *oint@$irgule

Instruction de structuration( if+ for+H.)

Instruction en -loc(*r5sence des O T )


26/133

)0gles d=écriture en Java 1DH4

Les diff5rentes entit5s utilis5es dans un *rogramme ( m5t6odes+ $aria-les+

classes+ o-/ets+ H.) sont mani*ul5es au tra$ers d8identificateurs .

n identificateur est form5 de lettres ou de c6iffres+ le *remier caractre 5tant@


.

minuscules a@_+ ainsi que le caractre ` soulign5 ( X ) et le caractre b

;em*le !

ligne Cla$ier $aleurX: Xtotal X:= btotal 2nom-re

Demarque trs im*ortante !

#a$a est trs sensi-le 9 la casse ! ligne [ Ligne .


27/133

)0gles d=écriture en Java @DH4

a-stract assert -oolean -rea0 -te

n identificateur ne *eut *as a**artenir 9 la liste des mots r5ser$5s dulangage #a$a !


continue default do dou-le elseetends false final finall floatfor if im*lements im*ort instanceofint interface long nati$e ne7null *ac0age *ri$ate *rotected *u-lic

return s6ort static su*er s7itc6snc6roni_ed t6is t6ro7 t6ro7s transienttrue tr $oid $olatile


28/133

)0gles d=écriture en Java HDH4

oici quelques con$entions de codage en /a$a

*u-lic class MaPremiereClasse

O *u-lic $oid affic6e( int argument )

om de classe commence *arune ma/uscule.

Mr SYLLA. Ingenieur en informatique2?

O int nom-re;ntier [12 + i [1

final float "M


29/133

Kocumentation en ligne et utilisation de classes

Pour *ou$oir utiliser une classe+

il faut et il suffit de connaVtre son interface(la d5claration comment5e de tous les mem-res *u-lics)consulta-le grce 9 la documentation en ligne

Mr SYLLA. Ingenieur en informatique 2&

etra t e a ocumentat on en gne e erm na

NN cr5e un erminal de titre BtitreB et de taille en *iels B7B N B6B N*u-lic MJrame (String titre+ int 7+ int 6)O...TNN Affic6e un BmessageB et rend lBentier lu 9 *artir de la consoleN*u-lic int readInt (String message)NN affic6e lBentier BiB dans la console N

*u-lic $oid *rintln (int i) O...T

MJrame fen [ ne7 MJrame (Rri fusionR+3''+3'')int taille [ fen.readInt ( RKonner un entierR)fen.*rintln (tailleNtaille)


30/133


31/133

A *ro*os des commentaires

Commenter tou/ours les entUtes de fonctions

n -on commentaire *ermet de *ou$oir utiliser la fonctionsans consulter le code.


% il indique 9 lBaide dBune *6rase le rGle de la fonction en faisant

inter$enir le nom de tous les *aramtres% il *r5cise le rGle de c6aque *aramtre

% il indique la signification du r5sultat retourn5% il indique les restrictions sur la $aleur des *aramtres

Commenter si n5cessaire des fragments de codes difficiles(un -on *rogramme en contient g5n5ralement *eu)

$iter les commentaires inutilesA [: N a *rend la $aleur : N


32/133

*


33/133

Les commentaires #AAK"C

Les commentaires /a$adoc NN H N

sont des commentaires s*5ciau*ermettant la *roduction automatique de documentation

au format 6tml.Ils sont *lac5s /uste a$ant ce quBils commentent.


-alises de commentaires#AAK"Cde classe

-alises de commentaires#AAK"C

de fonction

see ]une autre classe\aut6or ]nom de lBauteur\$ersion ]n de $ersion\

*aram ]nom *aramtre\ ]descri*tion\return ]descri*tion\ece*tion ]nom ece*tion\ ]descri*tion\since ]n de $ersion\

de*recated


34/133

Contenu dBune documentation /a$adoc

Kescri*tion g5n5rale de la classe

Kescri*tion des attri-uts (JI;LK)


Kescri*tion des constructeurs (C"SDC"D)

Kescri*tion des m5t6odes (M;"K)

La descri*tion des attri-uts+ des constructeurs et des m5t6odes *u-lics est donn5e@ -ri$ement en d5-ut de document@ en d5tail dans la suite du document.


35/133

La commande /a$adoc

E;;DAI" K; LA K"CM;AI" /a$adoc @d ]r5*ertoire o doi$ent Utre mis les fic6iers g5n5r5s\

@source*at6 ]r5*ertoire(s) de -ase des fic6iers sources\]nom du *aquetage\


@ source*at6le(s) r5*ertoire(s) de -ase des sources

(sBil en a *lusieurs+ s5*arer *ar des (,indo7s) ou ! (linu))

La documentation est ensuite consulta-le 9 *artir du fic6ier inde.6tml du r5*ertoirementionn5 a$ec lBo*tion @d .


36/133

La commande /a$adoc! eem*le

Pour g5n5rer la documentation des classes du *aquetage essai /a$adoc @d K!allslla/a$a*rogdoc

@source*at6 C!sllasrcessai


Pour g5n5rer la documentation des classes des *aquetages essai (dans C!slla)et eem*le.test (dans K!allslla)

/a$adoc @d K!allslla/a$a*rogdoc@source*at6 C!sllasrcK!allsllasrcessai eem*le.test

JI K CAPID;


37/133

Chapitre HLes *


38/133

Le t4?3=4? 9 214>4?3=4>long =4 -its ! h&2233>2'3=?:4>>:?'? 9 &2233>2'3=?:4>>:?'>

Les t*es 5l5mentaires ont une taille idenque quelque soit la *latehforme

dBe5cution.


39/133

Le t


40/133

Le t


41/133

Le t


42/133

Initialisation des varia!les 1D@4

;em*le !

int nom-re d5claration de la $aria-le nom-renom-re [ 1'' initialisation de la $aria-le nom-re


int nom-re [ 1'' d5claration et initialisation de la $aria-le nom-re

Demarque !ne $aria-le mani*ul5e dans une m5t6ode ($aria-le locale4 ou un !loc de$ratou/ours Utre initialis5e a$ant toute utilisation.

La d5claration d8une $aria-le r5ser$e de la m5moire *our stoc0er sa $aleur .

t*enom

$aleur [ o*5rateur d8affectation( associatif de droite 9 gauc6e)


43/133

Initialisation des varia!les @D@4

;n /a$a+ toute $aria-le a**artenant 9 un o-/et (d5finie comme 5tant un attri-ut delBo-/et) est initialis5e a$ec une $aleur *ar d5faut en accord a$ec son t*e au momentde la cr5ation.Cette initialisation ne sBa**lique *as au $aria-les locales des m5t6odes de la classe(cf !remarque *r5c5dente).


TYPE VALEUR PAR D FAUT

boolean falsebyte, short, int, long 0

float, double 0.0char u\000classe null


44/133

Utilisation des varia!les


*u-lic class tilaria-leO String c6aine DD varia!le de t


45/133

varia!les finalesle mot clé final4

#a$a *ermet de d5clarer que la $aleur d8une $aria-le ne doit *as Utre

modifi5e *endant l8e5cution du *rogramme

*ac0age 6ome.user./a$a.essai *u-lic class aria-leJinale

ne fois con$ena-lementinitialis5e une $aria-le finale


na ong "M


46/133

Les (pérateursarithmétiques !inaires4


*u-lic class "*XArit6X


47/133


48/133

Les (pérateurspriorité4

Lorsque *lusieurs o*5rateurs a**araissent dans une mUme e*ression+ ilest n5cessaire de sa$oir dans quel ordre ils sont mis en /eu

Les o 5rateurs unaires F et ont la riorit5 la lus 5le$5e.


"n trou$e ensuite au mUme ni$eau+ les o*5rateurs N+ et .Au dernier ni$eau+ se retrou$ent les o*5rateurs -inaires F et @.

;n cas de *riorit5 identique + les calculs s8effectuent de gauc6e 9

droite. "n dit que l8on a une associati$it5 de gauc6e 9 droite.


49/133

pac$age home7user7%ava7essai G D test sur la division par ero de nom!res entiers D

pu!lic class *est K

-xception sur la manipulationdes opérateurs1D@4


K

int valeurN1OGdou!le r5sultat N valeur D OGS


50/133

-xception sur la manipulationdes opérateurs@D@4

Pour les entiers+ la di$ision *ar _5ro (*ar ou ) conduit 9 une erreur

d8e5cution. Plus *r5cis5ment+ il a d5clenc6ement de ce que l8on nomme uneece*tion de t*e Arit6metic;ce*tion.

ous $errons *lus tard comment traiter les ecce*tions.

Mr SYLLA. Ingenieur en informatique:'

Si nous ne le faisons *as+ nous a-outissons 9 l8arrUt de l8e5cution du*rogramme+ a$ec un message de ce t*e!

;ce*tion in t6read ` main /a$a.lang.Arit6metic;ce*tion! - _5ro atest.main ( est./a$a!&)

D;MADZ; !Pour les flottants+ aucune o*5ration ne conduit 9 un arrUt del8e5cution (*as mUme une di$ision *ar _5ro ) seulementon a une $aleur non e*loita-le.


51/133

Conversions implicites1DR4

Les o*5rateurs arit6m5tiques ne sont d5finis que lorsque leurs deu o*5randessont de mUme t*e. Mais+ $ous *ou$e_ 5crire des e*ressions mites danslesquelles inter$iennent des o*5randes de t*es diff5rents.

u-lic class Con$ersionLe ale'1 O

Mr SYLLA. Ingenieur en informatique :1

*u-lic static $oid main(String args Q)

O int a [ 1' float * [14 dou-le d[ * F a

Sstem.out.*rintln(Rla $aleur de lBe*ression mite (*Fa) est !RFd)T

T

La valeur de l8expression mixte p#a4 est 5 @7O


52/133

Conversions implicites@DR4

dou!le dN p # aG

ta*e 1! a est con$erti en float+ * reste float


# ta*e 2! on effectue *Fa qui sera de t*e float

ta*e 3! le r5sultat est con$erti

en dou-le

ta*e 4! le r5sultat est stoc05 (affectation)dans la $aria-le d

Ces 4 5ta*es sont

r5alis5es *ar lecom*ilateur d8o

con$ersionsim*licites


53/133

Conversions implicitesHDR4

Con$ersions d8a/ustement de t*e

ne con$ersion telle que int en float est a**el5e a/ustement de t*e .;lle ne *eut se faire que sui$ant une 6i5rarc6ie qui *ermet de ne *as


int @\ long @\float @\dou-le

< ! une con$ersion de dou-le en float ( *ar eem*le) n8est *as l5gale .*our l8eem*le *r5cdent on ne *eut *as faire !int 0 [ * F a erreur de com*ilation


54/133

les o 5rateurs num5ri ues ne sont as d5finis our les t es - te c6ar

Conversions implicitesDR4

Promotions num5riques


et s6ort.oute o*5ration qui utilise l8un de ces t*es n5cessite une con$ersion*r5ala-le dans le t*e intCette con$ersion *orte le nom de *romotion num5rique .


55/133

*u-lic class Con$ersionLegale'2 O*u-lic static $oid main(String args Q)

O c6ar c [ jd8 le code du caractre jd8 est con$erti en ints6ort s [' la $aria-le s est con$ertie 5galement en int

Conversions implicitesRDR4

Mr SYLLA. Ingenieur en informatique ::

int n[ c F s le r5sultat de t*e int est affect5 9 nSstem.out.*rintln(Rla $aleur de lBe*ression mite (cFs) est !RFn )

TT

La valeur de l8expression mixte c#s4 est 5 1OO


56/133

Les opérateurs relationnels1D@4

Opérateur signification<

== =

!=

supérieur ou égal àégal à

différent de

m me *r or + ma s

celle@ci est inf5rieur 9celle des *r5c5dents

Ces o*5rateurs sont moins *rioritaires que les o*5rateurs arit6m5tiques.Ils soumettent eu aussi leurs o*5randes au *romotions num5riques eta/ustement de t*e .


57/133

*u-lic class "*erXDelat O*u-lic static $oid main(String args Q)

O int n [ 1' s6ort s [1'

Les opérateurs relationnels@D@4

-xemple 5

Mr SYLLA. Ingenieur en informatique :>

float [ 1''dou-le d[ 2''Sstem.out.*rintln(RAffic6age 1 !RF(n [ [ s) )Sstem.out.*rintln(RAffic6age 2 !RF(d ][ ) )

T

T Affichage 1 5 true Affichage @ 5 false


58/133

Les opérateurs logiques1DH4

O érateur Si nification

#a$a dis*ose d8o*5rateurs logiques class5es *ar ordre de *riorit5sd5croissantes (il n8eiste *as deu o*5rateurs de mUme *riorit5).

Mr SYLLA. Ingenieur en informatique :?

!&

^

|

&&||

négationet

ou exclusif

ou inclusif

et(avec cout-circuit)Ou inclusif(avec court-circuit

Le r5sultat est

tou/ours un

-ool5en.


59/133

(a]-) (c]d) ou (a]-) (c]d)

*rend la $aleur true ($rai) si les deu e*ressions a]- et c]d sont toutes lesdeu $raies (true)+ la $aleur false (fau) dans le cas contraire.(a]-) (c]d) ou (a]-) (c]d)*rend la $aleur true si l8une au moins des deu conditions a]- et c]d est

Les opérateurs logiques @DH4

Mr SYLLA. Ingenieur en informatique :&

$raie+ la $aleur false dans le cas contraire.

(a]-) (c]d)*rend la $aleur true si une et une seule des deu conditions a]- et c]d est$raie+ la $aleur false dans le cas contraire.(a]-)*rend la $aleur true si la condition a]- est fausse+ la $aleur false dans le

cas contraire. Cette e*ression *ossde la mUme $aleur que a\[-.


60/133

Les opérateurs logiques HDH4

Les o*5rateurs de cout@circuit et .

Ces deu o*5rateurs reclent une *ro*ri5t5 trs im*ortante!leur second o*5rande (figurant 9 droite de l8o*5rateur) n8est

Mr SYLLA. Ingenieur en informatique ='

*our d5cider si l8e*ression corres*ondante est $raie oufausse.

-xemple 5( 1: ]1' ) ( 1' \ 4) on 5$alue 1: ]1' + le r5sultat

est fau donc on n8 5$alue *as 1' \ 4

é


61/133

(pérateursd=incrémentation et de décrémentation1D@4

incr5mentation

int i N 1O G

i## G DD cette expression vaut 1O

-n fait en 5crivant 5int nN i## Gon a 5

*ost incr5mentation

Mr SYLLA. Ingenieur en informatique =1

DDmais i vaut 11

int % N 1O G

##% G DD cette expression vaut 11 DDet % vaut aussi 11

nN i G

i N i#1 G-t en 5crivant 5int pN ##% Gon a5 % N %# 1 Gp N% G*r5 incr5mentation

Il eiste un o*5rateur de d5cr5mentation not5e & &


62/133

( é t


63/133

(pérateurs

d=affectation élargie

int iN @O Gi N i # 1 G DD i vaut @1

i #N 1 G DDi vaut aussi @1!


64/133

(pérateurs


65/133

p

de manipulation de !its 1DH4

Opérateur Signification

Ils tra$aillent sur le motif -inaire d8un ;I;D+ a$ec *ossi-ilit5 de

con$ersions im*licites.

"*5rateurs -it 9 -it

Mr SYLLA. Ingenieur en informatique =:

&

|

^

>>>>

~(unaire)

Et (bit à bit)

Ou inclusif(bit à bit)

Ou exclusif(bit à bit)

Décalage à gauche

Décalage arithmétique à droiteDécalage logique à droite

Complément à un (bit à bit)

Opérande 1Opérande 2

00

01

10

11

&

|

^

0

0

0

0

1

1

0

1

1

1

1

0

(pérateurs


66/133

p

de manipulation de !its @DH4

"*5rateur de d5calage ]]

n de t


67/133

(pérateurs

de manipulation de !its HDH4

"*5rateur de d5calage \\ et \\\

n de t

n222Hrésultat 111O111OO11O1111111O111O1OO111O

résultat OOOO111OO11O1111111O111O1OO111O

Les !its de gauche sont des !its identiques au !it de signe7222 identique 9 22 sauf que tous les !its de gauche sont 9 5ro7

(pérateur


68/133

ConditionnelY 5

Mr SYLLA. Ingenieur en informatique =?

temps NE!eauE

elsetempsNE mauvaisE

temps NcielNN!leu YE!eauE 5 E mauvaisE

'riorité des opérateurs 1D@4


69/133

'riorité des opérateurs 1D@4

ordre de priorité décroissante4

les parenthèses ( )

les opérateurs d'incrémentation ++ -- --

les o érateurs de multi lication division et *

Mr SYLLA. Ingenieur en informatique =&

modulo

les opérateurs d'addition et soustraction + -

les opérateurs de décalage >

les opérateurs de comparaison < > =


70/133

les opérateurs d'égalité == !=l'opérateur OU exclusif ^

l'opérateur ET &

'riorité des opérateurs @D@4ordre de priorité décroissante4

Mr SYLLA. Ingenieur en informatique >'

l'opérateur OU |

l'opérateur ET logique &&

l'opérateur OU logique||

les opérateurs d'assignement = += - =

JI K CAPID;

Chapitre


71/133

Chapitre Les structures de contrTle

Les instructions d’un programme (main) sont à priori exécutées de façonséquentielle.

Les instructions de contrôle permettent de s’affranchir de cet ordre poureffectuer des choix et des boucles.

Mr SYLLA. Ingenieur en informatique >1

CHOIX :

BOUCLES :

if ….. else

switch

for ,

whiledo … while

break

continue

Branchement inconditionnel

Choix 5if "else


72/133

if "else

s6itch

package home.user.java.essai ;public class Exemple_If_Else{int final MIN = 100;int final Max = 1000;int solde ;

package home.user.java.essai ;public class Exemple_Switch{int final MIN = 100;int final Max = 1000;int choix , solde;


pu c s a c vo ma n r ng args

{ if ( solde < MIN)System.out.println("solde insuffisant" ) ;else

if (solde = = MAX)System.out.println("solde suffisant" ) ;

}

}

pu c s a c vo ma n r ng args

{ switch(choix){ case 1: solde = MIN;System.out.println("solde insuffisant" )

break;case 2: solde = MAX ;

System.out.println("solde suffisant" ) ;break;default : break

} }}

S


73/133

s6itch

if (condition)

instruction_1

[ else

Condition booléenne ( true / false )Expressions quelconques


_ es croc e s ren ermen es ns ruc ons

facultatives.switch (expression)

{ case constante_1 : [suite_d’instruction_1 ]

case constante_2 : [suite_d’instruction_2 ]…………………..case constante_n : [suite_d’instruction_n ][ default : suite_d’instructions ]

}

Expression de type byte, char,short ou int .

Expression constante d’ untypecompatible par affectationavec

le type de expression

L=instruction


74/133

do 6hilepackage home.user.java.essai ;import java.util.Scanner ; // importation de classe de l’ API

public class Exemple_Do_While{public static void main (String args [ ]){ Scanner clavier = new Scanner (System.in) ;

do


{ System.out.println ("saisir un entier strictement positif " ) ;

n = clavier.nextInt ( ) ; // saisir à partir du clavierif ( n < 0) System.out.println ("la saisie est invalidée: recommencez" ) ;

}while ( (n < 0) || (n = = 0) );

}}

do instruction

while (condition) ;

Expression quelconque

Condition booléenne

L=instruction


75/133

6hile

package joseph.cours.java ;public class Exemple_While{public static void main(String args [ ]){ while ( n < = 0)

{ System.out.println ("saisir un entier strictement positif " ) ;

Mr SYLLA. Ingenieur en informatique >:

n = clavier.nextInt( ) ; // saisir à partir du clavier

if ( n < 0) System.out.println ("la saisie est invalidée: recommencez" ) ;}

}}

while (condition) ;

instruction

Condition booléenne

Expression

quelconque

L=instruction


76/133

for

package joseph.cours.java ;public class Exemple_For{public static void main (String args [ ]){ int tab [ ] = new int [ 100] ; // tableau d’entiers de taille 100

for( int i = 0 ; i < 100 ; i ++ )

Mr SYLLA. Ingenieur en informatique >=

{

tab [ i ] = i + 1;}

}}

for ( [initialisation] ;[condition] ; [incrémentation])

instruction

+ranchement inconditionnel


77/133

!rea$ D continue

Elle sert à interrompre le déroulement de la boucle, en passant àl’instruction suivant la boucle.

Ces instructions s’emploient principalement au sein des boucles.

breakpackage joseph.cours.java ;

Mr SYLLA. Ingenieur en informatique >>

public class Exemple_Break{

public static void main (String args [ ]){ int tab [ ] = new int [ 10] ; // tableau d’entiers de taille 10for( int i = 0 ; i < 10 ; i ++ )

{ if ( i = = 5 ) break ; // initialiser seulement les 5 premiers elts du tableautab [ i ] = i + 1;

} // le break nous branche à la sortie du for pour continuerfor ( int i = 0 ; i < 10 ; i ++ )

System.out.println (" éléments du tableau:" +" "+tab [ i] );}

}

éléments du tableau: 1 2 3 4 5 0 0 0 0 0


78/133

package home.user.java.essai;public class Essai_Break_Imbr {

public static void main (String args [ ]){ int tab [ ] = new int [ 10] ; // tableau d’entiers de taille 10for( int i = 0 ; i < 10 ; i ++ )

En cas de bouclesimbriquées,l’instruction breakfait sortir uniquementde la boucle la plusinterne.

!rea$ avec im!rication de !oucles

Mr SYLLA. Ingenieur en informatique >?

for ( int j =i;j


79/133

!rea$ avec étiquette

package joseph.cours.java;public class Essai_Break_Etiq {

public static void main (String args [ ]){ int tab [ ] = new int [ 10] ; // tableau d’entiers de taille 10repeat: for( int i = 0 ; i < 10 ; i ++ )

Mr SYLLA. Ingenieur en informatique >&

for ( int j =i;j


80/133

continue

Continue ordinaire

L’instruction continue permet de passer prématurément au

tour de boucle suivant.

package joseph.cours.java ;

Mr SYLLA. Ingenieur en informatique ?'

_ _ public static void main (String args [ ])

{ int tab [ ] = new int [ 10] ; // tableau d’entiers de taille 10for( int i = 0 ; i < 10 ; i ++ ) // ici

{ if ( i = = 5 ) continue ; // on poursuit la boucle fortab [ i ] = i + 1;

}for ( int i = 0 ; i < 10 ; i ++ )System.out.println (" éléments du tableau:" +" "+tab [ i] );

}} éléments du tableau: 1 2 3 4 5 0 6 7 8 9 10


81/133

Continue avec étiquette

package home.user.java.essai;public class Essai_Continue_Etiq {

public static void main(String args [ ]){ int tab [ ] = new int [ 10] ; // tableau d’entiers de taille 10again: for( int i = 0 ; i < 10 ; i ++ ) // cette fois le continue branche ici

Mr SYLLA. Ingenieur en informatique ?1

{

for ( int j =i;j


82/133

'rogrammation (rientée (!%et

Le concept de classe

Une classe est la description d’un ensemble de données et de fonctionsregroupées au sein d’une même entité (appelée objet).

Mr SYLLA. Ingenieur en informatique?2

d’un objet du monde réel.

Un objet sera défini comme étant une entité concrète ou abstraite dumonde réel. Les objets contiennent des attributs et des méthodes.Chaque objet sera caractérisé par son jeu de données( on parlera d’

attributs ou aussi de champs). Les fonctions qui agissent sur lesdonnées de l’objet sont aussi appelées méthodes.


83/133

(!%et N identité # état # comportement

- une identité qui lui est propre :

Même si deux personnes ont des noms identiques, elles désignent deux

Chaque objet possède :


. .

- un état : les informations qui lui sont propresIl est défini par les valeurs associées à chacun des champs de la classe.Pour une personne : nom ,prénom, age, sexe, race ……

- un comportement : les méthodes applicables à l’objetPour une personne : respirer, marcher, mourir ……


84/133

Définition d’une classe

Les champs x et y ne sont visiblesq’à l’intérieur de la classe et non àl’extérieur :principe de l’encapsulation desdonnées. Les données ne seront

La méthode est accessible depuis n’

importe quel programme.


accessibles que par l’intermédiaire

de méthodes prévues à cet effet.

{

private int x ; // champ x d’un objet Pointprivate int y ; // champ y d’un objet Pointpublic void initialise ( int abs, int ord ){ x = abs ;

y = ord ;}

} // fin de la classe

Permet d’attribuer des valeurs initiales

aux champs de l’objet.NB :on verra que c’est au constructeurd’effectuer ce travail.

Une méthode qui nefournit aucun résultat:

void


85/133

Remarques

Une méthode peut être déclarée private : dans ce cas elle n’est visiblequ’à l’intérieur de la classe où elle est définie. Pour pouvoir l’utiliser dans

Mr SYLLA. Ingenieur en informatique?:

,publique de sa classe ayant l’appelée.

Il est fortement déconseillé de déclarer des champs avec l’attribut public ,cela nuit à l’encapsulation des données.


86/133

Créer un o!%et N instancier une classe

int a = 10 ; // réservation de l’emplacement mémoire pour une variable de type int

float x ; // réservation de l’emplacement mémoire pour une variable de type floatPoint a ; // cette déclaration ne réserve pas d’emplacement pour un objet de type // mais simplement une référence à un objet de type Point.

Mr SYLLA. Ingenieur en informatique?=

La création d’un objet (on parle d’instanciation ) se fait avec l’opérateur newnew Point ( ) ; // crée un emplacement pour un objet de type Point et

// fournit sa référence comme résultat

on pourra écrire :

a= new Point ( ) ; // crée un objet de type Point et on met sa reference dan // la variable a ?

?

x

yréférencea

objetPoint


87/133

;anipulation d=o!%ets

Une fois q’une référence à un objet est convenablement initialisée,on peut appliquer n’importe quelle méthode à l’objet correspondant .

a.initialise ( 2,4 ) ; //appelle la méthode initialise du type Point en ’ ’

Mr SYLLA. Ingenieur en informatique?>

, // les arguments 2 et 4

Opérateur d’accès.


88/133

class Point01{

private int x ; // champ x d’un objet Pointprivate int y ; // champ y d’un objet Pointpublic void initialise ( int abs, int ord )

'etit programme de test

On a deux classes dans le

même fichier source. Seulela classe contenant leprogramme principal( main)

Mr SYLLA. Ingenieur en informatique??

{ x = abs ;

y = ord ;}} // fin de la classe Point01public class TestPoint01{ public static void main( String args [ ] )

{ Point01 a = new Point01 ( ) ;a.initialise( 10,12 ) ; // le champ x aura la valeur 10 et y 12}

} // fin de la classe TestPoint01

o re c ar e avecl’attribut public.


89/133

Le constructeur 1DH4

En Java, la création d’objet se fait par allocation dynamique grâce à

l’opérateur new qui appelle une méthode particulière : le constructeur.Dans l’exemple précèdent, il n’y avait pas de constructeur mais plutôt c’étaitla méthode initialise qui se chargeait d’initialiser correctement les champs

Mr SYLLA. Ingenieur en informatique?&

d’un objet de type Point. La démarche proposée suppose que l’utilisateur fera

appel de cette méthode au moment opportun pour initialiser correctement unobjet.En fait un constructeur permet d’automatiser l’initialisation d’un objet.

Un constructeur est une méthode qui porte le même nom que lenom de la classe et qui est sans valeur de retour. Il peut disposd’un nombre quelconque d’arguments.


90/133

Le constructeur @DH 4

class Point02{

private int x ; // champ x d’un objet Pointprivate int y ; // champ y d’un objet Pointpublic Point02 ( int abs, int ord ) // un constructeur à deux

Mr SYLLA. Ingenieur en informatique&'

arguments

{ x = abs ;y = ord ;}

public void deplace (int dx, int dy ){ x += dx ; y += dy ;

}public void affiche( ){ System.out.println("Point de coordonnées" + x + " et " +y);}

} //fin de la classe Point02

D 4


91/133

public class TestPoint02{ public static void main( String args [ ] )

{ Point02 a = new Point02 ( 10, 12 ) ; // le champ x aura la valeur 10 ety 12 a.affiche( ) ;

a.deplace( 10,12 ) ;

Le constructeur HDH4

Mr SYLLA. Ingenieur en informatique&1

a.affiche( ) ;

} // fin de la classe TestPoint02

Point de coordonnées : 10 et 12

Point de coordonnées : 20 et 24

Zuelques r0gles sur les constructeurs


92/133

Une classe peut disposer de plusieurs constructeurs: ils se différencieront par le nombr

et le type de leurs arguments.

Une classe peut ne pas disposer de constructeur; dans ce cas on peut instancier des’

Mr SYLLA. Ingenieur en informatique&2

.

Mais dès qu’une classe possède au moins un constructeur, ce constructeur par défautne peut plus être utilisé, dans le dernier exemple on ne pouvait pas faire :

Point a = new Point ( ) ;// incorrect s’il y’a un constructeurUne classe peut disposer d’un constructeur sans arguments qui est bien différent duconstructeur par défaut (appelé souvent pseudo-constructeur).

Un constructeur peut appeler un autre constructeur de la même classe (A VOIR).

Un constructeur peut être déclaré public ou privé.

C t ti d= !% t


93/133

Construction d=un o!%et

La construction et l’initialisation des champs d’un objet se font en 3 étapes :

l’initialisation par défaut de tous les champs à une valeur "nulle", l’initialisation explicite lors de la déclaration du champ, l’exécution des instructions du constructeur.

Mr SYLLA. Ingenieur en informatique

&3

public class TestInit{ private int nombre ;private int diviseur = 12 ;public TestInit( ) { nombre = 24 ;}public float diviser( ){ return (float) nombre / diviseur ;}

}

nombre = 0diviseur =0

nombre = 0diviseur =12

nombre =24diviseur =12

Résultat : 2.0

.aleur "nulle" suivant le t


94/133

*


95/133

final

public class ChampFinal

{ private final int NOMBRE ; // initialisation différéeprivate final float MAX ; // initialisation différéeprivate final int DIVISEUR = 12 ; // valeur fixée à la déclaration


&:

public ChampFinal( int nbre)

{ NOMBRE = nbre ; // la valeur de NOMBRE dépendra de celle de nbreMAX = 20 ; // la valeur de MAX est fixée à 20 une seule fois.}

public float diviser( ){ return (float) NOMBRE / DIVISEUR ;}

}ATTENTION: chaque objet possédera son propre champ NOMBRE,malgré que ce dernier est déclaré final.

Contrat et implémentation


96/133

Une bonne conception orientée objets s’appuie sur lanotion de contrat , qui revient à considérer q’une classe estcaractérisée par un ensemble de services définis par :-- les en-têtes de ses méthodes publiques ,-- le comportement de ses méthodes .


&=

Le reste, c’est-à-dire les champs et les méthodes privés

ainsi que le corps des méthodes publiques, n’a pas à êtreconnu de l’utilisateur . Il constitue ce que l’on appellesouvent l’implémentation de la classe .En quelque sorte, le contrat définit ce que fait la classetandis que l’implémentation précise comment elle le fait .

Le grand mérite de l’encapsulation des données est depermettre au concepteur d’une classe d’en modifierl’implémentation sans que l’utilisateur n’ait à modifier lesprogrammes qui l’exploitent .

Affectation d=o!%ets


97/133

Point a ;

a = new Point (12,10 ) ;

11

12

10a


&>

o n = new o n , ;

b

a = b ;1210

1114

a

bSera candidat auramasse-miettes

s’il n’est plus référencéDésormais a et b désignent le même objet.

affectation d’objet

)éférence nulle5 le mot clé

null


98/133

nullclass Point03{

private int x ; // champ x d’un objet Pointprivate int y ; // champ y d’un objet Pointpublic Point03 ( int abs, int ord ) // un constructeur à deux arguments


&?

{ x = abs ;y = ord ;

}public Point03 coincide (Point03 p )

{ Point03 t = null ; // t est locale donc il est nécessaire de l’initialiserif ((p.x = = this.x) && ( p.y = = this.y )) t = this;

else t = null;return t ;}

} //fin de la classe Point03

Les variables locales doivent

toujours être initialisées avant touteutilisation.

Comparaison d=o!%ets 1D@45

versus equals


99/133

N N versus equalspublic class Point03{ private int x ; // champ x d’un objet Point

private int y ; // champ y d’un objet Pointpublic Point03 ( int abs, int ord ) // un constructeur à deux arguments{ x = abs ;


&&

y = or ;}

public static void main(String args [ ] ){Point03 a = new Point03 ( 1,1 );Point03 b = new Point03 ( 1,1 );System.out.println ("avec = = : " + a == b);System.out.println ("avec equals :" + a.equals ( b ));

}} //fin de la classe Point03 Résultat avec = = : false

avec equals : false

Comparaison d=o!%ets @D@4


100/133

= = teste s’il s’agit du même objet ( pas d’une copie ).equals teste l’égalité de contenu de deux objets .


1''

ATTENTION :dans l’exemple précédent la méthode equals dont il s’agit est cellede la classe Object (la super classe de toutes les classes en Java).Souvent, vous serez emmené à redéfinir cette méthode.Elle a pour en-tête:

public boolean equals (Object o )

L’opérateur != s’applique également à des références d’objet pour tester la différence.

Champs et méthodes de classe5

le mot clé static


101/133

le mot clé static 7

Champs de classe

Les champs de classe ou champs statiques existent en un seul exemplaire pourtoutes les instances de la classe. On les déclare avec le mot clé static .


1'1

public class ChampStatic{

int n ;static int k ;

}

ChampStatic a = new ChampStatic( ) ;ChampStatic b = new ChampStatic( ) ;

a.nb.n

a.kb.k

a.k et b.k peuvent être remplacés par ChampStatic.k . Mais si k est privé, on nepeut faire ceci.

Exemple d’utilisation de champs de classe


102/133

public class ChampStatic {private static int nombreInstanceCrees; // champ static pour stocker le nombrepublic ChampStatic ( ) // d’objets créés

{ nombreInstanceCrees++; // on incrémente de 1 à chaque création d’un objet}

Mr SYLLA. Ingenieur en informatique1'2

public void affiche ( ){

System.out.println ("nombre d’objets créés :" + nombreInstanceCrees );}public static void main (String args [ ])

{ ChampStatic a = new ChampStatic ( );

a.affiche ( );ChampStatic b = new ChampStatic ( );b.affiche ( );

}}

nombre d’objets créés : 1nombre d’objets créés : 2


103/133

Méthodes de classe

Une méthode d’une classe ayant un rôle indépendant de toute instance de la classe doiêtre déclarée avec le mot clé static et elle ne ourra être a li uée à aucun ob et de c

Mr SYLLA. Ingenieur en informatique 1'3

classe, contrairement aux méthodes d’instances.

L’appel de la méthode ne nécessitera que le nom que de la classe.

ATTENTION :

Une méthode statique ne peut pas agir sur des champs usuel

c’est-à-dire non statiques.

Exemple d’utilisation de méthodes de classe


104/133

public class MethodeStatic {private long n;

private static long nombreInstanceCrees; // champ static pour stocker le nombrepublic MethodeStatic( long k) // d’objets créés

{ nombreInstanceCrees++ ;

Mr SYLLA. Ingenieur en informatique1'4

n = k ;}

public void affiche ( ){

System.out.println ("nombre d’objets créés :" + nombreObjet( ) );}

public static long nombreObjet( ){ return nombreInstanceCrees;}

}

Bloc d’initialisation statique


105/133

Remarque :

l’initialisation d’un champ statique se limite uniquement à :- l’initialisation par défaut,- l’initi lis tion ex licite éventuelle.

Mr SYLLA. Ingenieur en informatique 1':

Les blocs statiques sont souvent utilisés pour initialiser des variables complexes dont l’initialisation ne peut être faite par une simple instruction.Les instructions n’ont accès qu’aux champs statiques de la classe.

Les instructions d’un bloc statique sont exécutées de façon automatique et une seule fois

lorsque la classe est chargée.

Exemple d’utilisation de bloc statique


106/133

public class BlocStatic {private double solde;

private static int [ ] tab ;static { tab = new int[10]; // bloc d’initialisation délimité par des accolades

=


1'=

tab[ i ] = i + 1;

} // fin du bloc staticpublic BlocStatic (double solde) {this.solde = solde;

}public static void main(String[] args) {

BlocStatic a = new BlocStatic( 12000 ); for (int i=0;i < tab.length; i++)System.out.print (tab[i]+" ");

}} // fin de la classe

1 2 3 4 5 6 7 8 9 10

Surdéfinition de méthodes


107/133

Surdéfinition de méthodes

Mr SYLLA. Ingenieur en informatique 1'>

a sur n on e m o es s gn e qu un m me nom e m o

peut être utilisé plusieurs fois dans une même classe . Dans ce cle nombre et/ou le type des arguments doit nécessairement chan

On peut parler indifféremment de surdéfinition, surcharge ou

overloading (en Anglais).

Exemple de surdéfinition de méthode


108/133

public class ExempleSurdefinition {private int x ;

private int y ;public ExempleSurdefinition (int abs, int ord ) { x=abs; y=ord; }public void deplace (int dx, int dy) { x += dx ; y += dy ; }

Mr SYLLA. Ingenieur en informatique1'?

public void deplace (int dx ) { x += dx ;}

public void affiche(){ System.out.println(" Point de coordonnees :"+ x+ " "+y);}public static void main(String[] args) {ExempleSurdefinition ex = new ExempleSurdefinition(10,10);ex.deplace ( 10 ); // appel de deplace ( int )

ex.affiche ( );ex.deplace( 10, 10 ); // appel de deplace (int , int )ex.affiche( );}

}

Point de coordonnes : 20 10Point de coordonnes : 30 20


109/133

Surdéfinition de constructeurs


110/133

Les constructeurs peuvent être surdéfinis comme toute autre méthode.

public class Individu {private String nom;private String prenom; Attribut de t e

Mr SYLLA. Ingenieur en informatique11'

private Compte c;

/* constructeur à deux arguments*/ public Individu ( String lenom, String leprenom ) {nom = lenom;prenom = leprenom;

}

/* constructeur à trois arguments */ public Individu (String lenom, String leprenom, Compte cp) {nom = lenom;prenom = leprenom;c = cp; } }

objet. Il doit exister

obligatoirement uneclasse Compte.

*ransfert d=informations

avec les méthodes


111/133

avec les méthodesEn Java, la transmission d’informations se fait toujours par valeur.

La transmission, par exemple d’un argument à une méthode oud’une valeur de retour se fait toujours par valeur.


A RETENIRe e ransm ss on a es cons quences o a emen

différentes, selon que l’on manipule des types primitifs ou

bien des types objet ( c-à-d des références).

RAPPELTransmission par valeur : la méthode reçoit une copie de lavaleur de l’argument effectif sur laquelle elle travaille. Pas depossibilité d’agir sur la valeur de l’argument effectif.Transmission par référence ( par adresse): la méthode reçoitl’adresse de l’argument effectif sur laquelle elle travailledirectement. Ici, possibilité de modifier donc la valeur del’argument effectif.

Illustration de la transmission de messages avec

les méthodes (1/2)


112/133

public class TransValeurTypePrimitif {private double res;

public TransValeurTypePrimitif (double n) {res = n;

}

Argument muet.2


public double add ( double p ){

return res += p;}

public static void main(String[] args) {TransValeurTypePrimitif trans = new TransValeurTypePrimitif (12);

System.out.println ( trans.add ( 10 ) );}

}

10

10p

p contientune copiede la valeurde l’argumenteffectif.

Argument effectif.1

34

Illustration de la transmission de messages avec

les méthodes (2/2)


113/133

public class Point {private int x;

private int y;public Point (int abs, int ord) {x = abs;

Référence à un objet de type Pointtransmise en ar ument d’une


113

y = ord;}public boolean coincide ( Point p){return ( p.x == x && p.y == y);

}public static void main (String [ ] args) {Point a = new Point(10,12);Point b = new Point(12,12);System.out.println( a.coincide ( b ) );

}}

Méthode.

p

b

1212

a 1210

Autoréférence 5 this [4


114/133

Dans un appel de la forme a.coincide ( b ), la méthode reçoit une information lui

permettant d’identifier l’objet ayant fait l’appel. Si l’information est transmise, laméthode pourra agir sur les champs spécifiques de l’objet.Cette transmission est gérée automatiquement par le compilateur.


Mais on peut vouloir agir sur l’objet globalement au lieu d’agir sur les champs.

Dans ce cas Java utilise le mot clé

this. Dans l’exemple précédent, on peut remplace

la méthode coincide par celle-ci:

public boolean coincide ( Point p){ // this reference ici l’objet courant ie celui ayant fait l’appel de coincide

return ( p.x == this.x && p.y == this.y);}

Dans un appel a.coincide (b) a désigne l’objet courant.

Autoréférence 5 this @D@4


115/133

L’utilisation de this est très pratique dans l’écriture des méthodes et surtout des

constructeurs.


// noms de champs et noms d’attributs

//différentspublic Point ( int abs, int ord ) {x = abs;y = ord;

}

// noms de champs et noms d’attributs

//identiquespublic Point ( int x, int y ) {this.x = x;this.y = y;

}

Appel d=un constructeur dans un

autre constructeur7 1D@4


116/133

Un constructeur peut appeler un autre constructeur de la même classe en utilisant l

mot clé this. L’objectif majeur est la simplification du code et aussi pour desproblèmes de sécurité.

public class Individu {

Cette classe eut êtr


11=

private String nom;private String prenom;

private Compte c;public Individu ( String lenom, String leprenom ) {nom = lenom;prenom = leprenom;

}public Individu (String lenom, String leprenom, Compte c1) {nom = lenom;prenom = leprenom;c = c1;

} }

écrite de façon plussophistiquée commesuit …

Appel d=un constructeur dans un

autre constructeur7 @D@4


117/133

public class Individu2 {private String nom;

private String prenom;private Compte c;public Individu2 ( String nom, String prenom ) {


.this.prenom = prenom;

}public Individu2 (String nom, String prenom, Compte c) { // appel du constructeurs a deux arguments

this (nom, prenom);this. c = c;

} }

ATTENTION :L’appel this (…) doit nécessairement être la première instructiodu constructeur appelant.

(!%et mem!re


118/133

Objet membre = référence à un objet

public class Point { public class Cercle {


11?

private int y;

public Point (int abs, int ord) {x = abs;y = ord;

}public void affiche ( )

{System.out.println(" Point :" +x " " +y);}

}

private Point p; // objet membre

public Cercle (double r, int x, int y) {this.r = r;p = new Point (x, y);

}public void affiche ( )

{System.out.println("Cercle de rayon :" +r);System.out.print(" et de centre:" );p.affiche());

}}

Les classes internes


119/133

Une classe est dite interne lorsque que sa définition est située àl’intérieur de la

définition d’une autre classe. Les classes internes (inner classes)peuvent être situées à différent niveau d'une classe normale.Il existe uatre t es de classes imbri uées :


- les classes internes simples, définies au niveau des classes,- les classes internes statiques, représentant une classe de sommetintérieure,- les classes locales, définies au niveau des méthodes,- les classes internes anonymes, définies au niveau d'une instance.Les classes internes sont particulièrement utiles pour :

- permettre de définir une classe à l'endroit ou une seule autre en a besoin

- définir des classes de type adapter (essentiellement à partir du JDK 1.1 pour traiterdes évenements émis par les interfaces graphiques)- définir des méthodes de type callback d'une façon générale.

Classes internes simples(1/5)

package essai01;


120/133

package essai01;public class ClasseParente {

private int x = 10, static int y = 20;

public int addition ( ) { return (x + y); }public class ClasseInterne //DEBUT CLASSE INTERNE{ static int p = 20; //erreur de compilation,


s a c na n = ; cons an e s a quepublic int multiplier ( )

{ return x*y + addition ( ); }} //FIN CLASSE INTERNE

public static void main (String [ ] args) {ClasseParente ob_out = new ClasseParente ( );

//ClasseInterne ob_in0 = new ClasseInterne ( ); IMPOSSIBLE

ClasseInterne ob_in = ob_out.new ClasseInterne ( );System.out.println (ob_in.multiplier ( ));

// System.out.println (ob_out.multiplier ( )); //ERREUR // System.out.println (ob_in.addition ( )); IMPOSSIBLE

} }

Classes internes simples(2/5)


121/133

Une classe interne peut être déclarée avec n’importe quel modificateur d’accès ((

Quelques remarques importantes:


121

, , , , .Elles sont membres à part entière de la classe qui les englobe et peuvent accéder à tou

membres de cette dernière.Les classes internes ne peuvent pas être déclarées à l'intérieur d'initialiseursstatiques (blocs statiques).

Les classes internes ne doivent pas déclarer de membres statiques, sauf s'ils

comportent le modificateur final, dans le cas contraire, une erreur de compilation seproduit. Toutefois, les membres statiques de la classe externe peuvent être héritéssans problème par la classe interne.

Les classes imbriquées sont capables d'accéder à toutes les variables et méthodes dela classe parente, y compris celles déclarées avec un modificateur private.

Classes internes simples (3/5)


122/133

La notation particulière:

ClasseInterne ob_in = ob_out.new ClasseInterne();

On retient:


spécifie que l'objet créé est une instance de la classe interneassociée à l'objet résultant de l'instanciation d'une classe de plus haut niveau.L'instanciation de la classe interne passe obligatoirement par une instancepréalable de la classe d'inclusion.La classe parente est d'abord instanciée, puis c'est au tour de la classe interne de l'êtr

par l'intermédiaire de l'objet résultant de la première instance.



123/133

Il est possible d'utiliser une méthode de la classe parente pour créer directementune instance de la classe interne. Toutefois, lors de l'appel de la méthode, il sera

nécessaire de créer une instance de la classe d'inclusion.package essai0;

ublic class ClasseParente02


private int x = 10, int y = 20;public int addition ( ){ ClasseInterne02 obj_in = new ClasseInterne02( );

return (x + y)+ obj_in .multiplier ( );}public class ClasseInterne02

{ public int multiplier ( ){ return x*y ;}

}}


public class ClasseParente03 {


124/133

Parfois, il peut

être nécessairededistinguer les

public class ClasseParente03 {

private int x = 10, int y = 20 ;

public int addition( ){ ClasseInterne03 obj_in= new ClasseInterne03 (10,10);return (x + y)+ obj_in.multiplier();


variablessituées dans les

classesinterne etexterne.

public class ClasseInterne03

{ private int x = 12; private int y = 14;public ClasseInterne03 (int x, int y){ this.x = x + ClasseParente03.this.x;

this.y = y + ClasseParente03.this.y;}public int multiplier( )

{ return x*y ;} }}

Classes internes statiques

bli l P t 04 {

Elles sont membres à part entière de la classe qui les englobent et peuventaccéder uniquement aux membres statiques de cette dernière.


125/133

Les classes internesstatiques peuvent

accéder à l'ensembledes membresstatiques de leur

public class Parente04 {private static int x = 1, y = 2;

private int z = 3;public int addition ( ){ return x + y + z;}public static int multiplier( ){ return x*y;}


c asse paren e,l'instar des méthodes

de classe.private static int k = 1;private int p = 2;public void diviser ( ){ System.out.println (new Parente04( ).addition ( )/p+x+y);}}

public static void imprimer(){System.out.println ( multiplier ( ) / x+y+k );} }public static void main(String [ ] args) {Parente04.Interne04( ).imprimer ( );new Parente04.Interne04( ).diviser ( )} }

s a c

Classes locales


126/133

Une classe locale est définie à l'intérieur d'une méthode ou un bloc, et agît

librement et essentiellement au sein de cette dernière.Elles peuvent être static ou non.


Il n'est possible de déclarer des classes locales, dont la portée est limitée au bloc,

qu'avec les modificateurs final ou abstract. Les modificateurs suivants : public,protected, private et static, sont interdits.Les données membres d'une classe externe peuvent être accédés par la classe locale.

Seules les variables locales et les paramètres de la méthode d'inclusion, déclarée

avec le modificateur final, peuvent être exploitées par les classes internes locales,sinon une erreur se produit lors de la compilation. De plus, ces variables doiventêtre impérativement initialisées avant leur emploi dans la classe locale.

Classes locales

public class ClasseExterne {


127/133

public class ClasseExterne {private int x,y; private static int z;

public void addition( int p){final int k = 9;int u = 121; // inutilisable dans

p et u ne peuvent pasêtre utilisés dans ClassLocale.

Par contre , k est déclarée finaldonc on peut l’utiliser.


ClasseLocale

class ClasseLocale {boolean verif ( ){if (x+ y+ k = = z) return true;else return false;

}

}} // fin bloc de méthode

}

REMARQUE:

Lorsqu'une classe estdéclarée dans une méthodestatique, alors les variablesd'instances de la classe externene sont plus accessibles pour la

classe imbriquée.L'utilisation d'une classe localene dépend pas de l'instanciationd'une classe externe.

Classes anonymes


128/133

Les classes anonymes (anonymous classes) sont déclarées immédiatement après

l'expression d'instanciation d'une classe, permettant directement d'étendre oud'implémenter respectivement la classe ou l'interface instanciée.Elles sont définies et instanciées à la volée sans posséder de nom.


new Classe ([Liste d'arguments]) { // Instructions de la classe anonyme... };new Interface ( ) { // Instructions de la classe anonyme... };

Les classes anonymes obéissent aux mêmes restrictions que les classes locales et dene peuvent ni être abstraites (abstract) ni être statiques (static).Par contre, elles portent toujours implicitement le modificateur final.En fait, aucun modificateur n'est permis dans une déclaration de classe anonyme

On verra l’utilité des classes anonymes en programmation évènementielle.

3ros plan sur les pac$ages

Un package regroupe un ensemble de classes sous un même espace de nom


129/133

Un package regroupe un ensemble de classes sous un même espace de nomLes noms des packages suivent le schéma : name.subname…

Une classe Watch appartenant au package time.clock doit se trouverobligatoirement dans le fichier time/clock/Watch.class.


contenant les classes à charger.

L’instruction package indique à quel paquetage appartient la ou les classe (s)l’unité de compilation (le fichier).Les répertoires contenant les packages doivent être présents dans la variabled’environnement CLASSPATH.En dehors du package, les noms des classes sont: packageName.classNameL’instruction import packageName permet d’utiliser des classes sans lespréfixer par leur nom de package.Les API sont organisées en package ( java.lang, java.io, javax.swing,….)

?roits d=acc0s et paquetage


130/133

En Java, il y a quatre types de droits d’accès aux méthodes et aux champs d’un objed’une classe. Autrement dit, la portée de la visibilité des méthodes et champsest assurée par les mots clés: private, protected, vide (droit de paquetage), et public.

’


,Nous séparons la visibilité des champs et celle des méthodes.

Paquetage et visibilité des champs(encapsulation des membres)


131/133

class c1{public int a;

int b;protected int c;

rivate int d

class c4 extends c1{

….} a c



……}

class c3 {

….}

package A

class c5 {

…..}

package B

a b c a b c a

Exemple d’accès aux membres

sylla/classes/ graph/2D/ Circle java sylla/classes/ graph/3D/ Sphere java


132/133

sylla/classes/ graph/2D/ Circle.javapackage graph.2D;

public class Circle {…..}

sylla/classes/ graph/3D/ Sphere.javapackage graph.3D;

public class Sphere {…..}


sylla/classes/ TestPackage/ MainClass.java

package testpackage;import graph.2D.*;public class MainClass {public static void main (String args [ ]){

graph.2D.Circle c1= new graph.2D.Circle (50);

Circle c2 = new Circle (80);graph.3D.Sphere s1 = new graph.3D.Sphere (100); //OKSphere s2 = new Sphere (50), // error: class testpackage.Sphere not

found}

import graph.3D.Sphere, //nécessaire

Paquetage et visibilité des méthodes


133/133

class c1{public void f( );

void g( );protected void h( );

rivate void k


….} f( ) h( )


package A


……}

f( ) g( ) h( )

class c3 {

….}f( ) g( ) h( )

package B

class c5 {

…..}

f( )

FIN DU CHAPITRE

Documents

Cours Java Mit Sylla