Réaliser par
ilhame souda
Rachida oubouali
Doha ayougil
Hasna Amrani
Master science de
donnée et aide à l a
décision FSTG
Plan
Club SDAD
Introduction
general
Concepts de base
Classes,Objets,Tablea
ux
Interfaces,Classes
abstraites
Heritage,package,Class
es imbriquées
Exceptions,Chaine de
caracteres
Géniricité ,
Collections,Threads
3/
INTRODUCTION À
Les conceptsde base
Introduction
Approche OrientéeObjet
Le concept de programmation orienté objet vient de la volonté
d’avoir une représentation très proche du monde réel. En effet,ce
monde est constitué d'objets. Ils sont caractérisés par leur
dimension,leur poids, leur couleur,etc.
Le concept de programmation orientée objet vientdonc
pour répondreà un certain nombre d’objectifs dont:
Similarité avec le monde réel
Similaritéavec le langagenaturel
Prise en compte de l’évolution du besoin
Prise en compte des systèmesexistants
ClubSDAD
6/
Le modèleObjet
Principe/Avantages
Un objet est une abstraction d’un élément du monde réel.
(Exemple :Voiture) possède des informations (=attributs=l’état
de l’objet), par exemple Couleur,Matricule,modèle, etc., et se
comporte suivant un ensemble d’opérations qui lui sont
applicables: vitesse, accélérer, freiner, tourner,etc.
Objet = attributs+opérations
De plus, un ensemble d'attributs caractérisent l'état d'un objet,
et l'on dispose d'un ensemble d'opérations (les méthodes) qui
permettentd'agir sur le comportementde notreobjet.
Club SDAD
7/
Les concepts debase
Lesconceptsdebase
Qu’est-cequ’un objet?
9
En programmation orientée objet, chaque entité du monderéel
doit être représentée justement par un objet.
A chaque instant, cette entité(objet) est caractériséepar:
L’information qui ressortde la valeur des données(son état :
attribut)
Les opérations qui peuvent modifier son état ou interagiravec
les autres objets (méthodes)
L’identité qui caractérise l’existence propre d’un objet et permet
de distinguer deux objets dont toutes les valeurs d'attributs sont
identiques.
Objet
Club SDAD
Les concepts debase
Principe/Avantages
Les avantages de l’approcheobjet:
Programmation orientée objet apporte l’indépendance entre
les programmes, les donnéeset les procédures parce queles
programmes peuventpartager les mêmes objets sans avoir à
se connaîtrecomme avec le mécanismed’import/export.
La modélisation des objets de l’application :
informatiquementun ensembled’éléments d’une partiedu
monde réel en un ensemble d’entités informatiques. Ces
entitésinformatiquessont appeléesobjets
Le modèleObjet
Club SDAD
Lanotiondeclasse
Une Classe est un modèleinformatiquereprésentantune familled’objets
ayant :
✓ La même structurede données (même listed’attributs)
✓ Les mêmes méthodes (mêmescomportements).
La créationd’un objet en tant qu’exemplaire concret
(contenant
des données)d’une classe s’appelle une INSTANCIATION.
Chaque objet donne des valeurs aux attributsde laclasse.
Classe = attributs + opérations +instanciations
Les attributs (appelés aussi variables d'instances): Ils ont un nom ,
soit Un type primitif (Entier, Booléen,...) soit une classe (Rectangle,
Personne, ...) et unevisibilité
Classe
Les conceptsdebase
Club SDAD
Les concepts debase Classe
Lanotiondeclasse
Les opérations(méthodes): Elles sont les opérations applicables à un
objet de la classe. On a 5 catégoriesd’opérations:
Constructeurs (qui créent les objets), Destructeurs (qui
détruisentles objets), Sélecteurs (qui renvoienttout ou une partie
de l’état d’un objet), Modificateurs(qui changent tout ou partiede
l’état d’un objet), Itérateurs (qui visitent l’état d’un objet ou le
contenud’une structurede donnéescontenantdesobjets)
L’instanciation : L’objet possède une identité,qui permet de le
distinguerdes autres objets, indépendamment de son état.
Club SDAD
Lanotiondeclasse
Visibilité:
Il existe trois niveaux de visibilité :
publique : Les fonctions de toutes les classes peuvent accéder aux
données ou aux méthodes d’une classe définie avec le niveau de
visibilité public. Il s’agit du plus bas niveau de protection de données.
protégée : l’accès aux données est réservé aux fonctions des
classes héritières, c’est-à-dire par les fonctions membres de la
classe ainsi que des classesdérivées.
privée : l’accès aux données est limité aux méthodes de la classe
elle-même. Il s’agit du niveau de protection des données le plus
élevé.
Les concepts debase
ClubSDAD
Classe
Classe
La notion de classe
Les concepts debase
Exemple d’une classe enjava
Classe représentant un point deR2
Opération: translaterle point d’un vecteur(tx, ty)
public class Point
{ private double x;
private doubley;
public void translate(double x, doubley){ this.x += x;
this.y += y; }
}
public class Point : définitiond’une nouvelle classe Point
private double x : attributsde la classe avec mode d’accès private=
accessible uniquement depuis cette classe; accès à l’intérieur de la
classe : this.nomAttribut
public void translate(double tx, double ty) :méthodede laclasse
Club SDAD
Lesconcepts de base
L’analyse orienté objet
L’analyse orienté objet s’appuie sur les principes suivants :
Abstraction : décrire formellement les données et les traitements
en ignorants les détails.
Encapsulation : masquer les données et les traitementsen
définissant une interface.
Héritage : reprendreintégralementtoutce qui a déjà été faitet
de pouvoirl’enrichir : spécialisation.
Polymorphisme : le terme polymorphismeissu du grec
signifie la faculté
de prendre plusieursformes.
Messages : le seul moyen de communication entre lesobjets
et l’envoi de messages.
Club SDAD
Lesconcepts de base
Constructeur
Notiondeconstructeur
constructeur = méthode particulièrepermettantde créerdes
instancesde la classe
objectif = initialiser les différentsattributs
définitiond’un constructeur=
même nom que la classe
pas de type de retour
autant de paramètresque ce dont on abesoin
Il existe deux types de constructeur enJava:
-Constructeur sans argument : Un constructeursansparamètre
est appelé constructeur pardéfaut
Exemple:
Cube OB = newCube();
-Constructeur paramétré: Un constructeur qui a desparamètres
est appelé constructeurparamétré.
Exemple: Cube OB=new Cube(Stringnom, int age)
15
ClubSDAD
Conclusion
Prof. Said El Kafhali
AvantagesdelaPOO
les données sont protégéset accessibles d’une manière
bien
définie
la modification du code des méthodes d’une classe
n’influence en aucun cas les programmes externesutilisant
cette classe
les programmeurs peuventréutiliserdes composants
existants
Les conceptsdebase
ClubSDAD
Classes et objets Notion de classe en Java
Notion de Classes
Javaestunlangageobjet: toutappartientàuneclassesaufles
variablesdetypeprimitives.
Uneclassesecomposeendeuxparties:
• Lecorpspeutêtrediviséen2 sections:la déclarationdes
donnéeset desconstantesetladéfinitiondesméthodes.
• Lesméthodesetlesdonnéessontpourvuesd’attributsde
visibilitéqui gèreleuraccessibilitéparlescomposantshorsde
laclasse.
Un attribut est unedonnéed’uneclassedontla déclarationrespectela
syntaxe:
1 type_de_attribut nom_de_attribut = [valeur ] ;
ClubSDAD
Classes et d’objets
Notion de classes en java
Lesconstructeurs& lesméthodes d’uneclasse
Un constructeurestuneméthodeautomatiquementappeléelorsdela
créationd’une instance d’une classe.
Si aucunconstructeurn’est définiparle programmeur,java considère
quela classeestmunied’un constructeurpar défaut.
Unefonctiond’uneclasseestappeléeméthode.
Enjavauneméthodepeutretournerunevaleuretavoir unelistede
paramètres:
• Uneméthodepeutavoirun nombrequelconquede paramètres.
• Touslesparamètres sont passéspar valeur.
1 type_de_retour nom_de_méthode (liste_des_paramètres){
2 // corps de la méthode}
ClubSDAD
Classes et d’objets
Notion de classes en Java
Exemplede classe
ClubSDAD
Classes et d’objets
Notion d’objets en Java
Notion d’objets
La créationdesobjetsestréaliséeparl’opérateur new.
1 NomDeClasse objet;
2 objet=new NomDeClasse (paramètres de constructeur);
1 String S=newString("ceci est une chaîne de caract ères" );
Pouraccéderàuneclasseilfautendéclareruneinstancedeclasseouobjet.
Exemple: utilisationdelaclasseLivre
ClubSDAD
Classes et d’objets
Structure d’un programme Java
La méthodemain
Pour débuter une application on doit fournir un point d’entrée.
Lorsqu’uneclassesertd’application elledoit fournirce point d’entrée
qui estuneméthodestatiqueportantle nomde «main».
Cepoint d’entrée doit respecterla syntaxesuivante :
1 public stat ic void main( String [ ] args ){
2 / / Corps du point d’ entrée
3 }
Où «args»correspondà la listedesargumentspassédepuisla lignede
commande.
ClubSDAD
Classes etd’objets
Modificateurs et visibilité
Modificateurs et visibilité
lesmodificateurspermettantdecontrôlerl’accèsà uneclasse,une
méthodeouunevariable:public,privateetprotected.
Unedonnéeouméthodeprivateestinaccessibledepuisl’extérieur dela
classeoùelleestdéfiniemêmedanuneclassedérivée.
Unedonnéeouméthodepublicestaccessibledepuisl’extérieur dela classeoù
elleestdéfinie.
Unedonnéeou méthodeprotectedestprotégéedetout accèsexternecomme
privatesaufàpartirdesclassesdérivées(accessibledansuneclassefille).
Le modificateur static : est utilisé pour définir des variables ou des
méthodesdeclasse.Lemot-cléstaticindiquequel’élémenteststocké
danslaclasse.
Le modificateurfinalindiquequela « variable» estconstante.
ClubSDAD
Les tableaux
Les tableaux à une seule dimension
Tableauxà uneseuledimension
Un tableauestunestructurededonnéescontenantun groupe
d’élémentstousdu mêmetype.
1 Type NomDuTableau[];
Lestableaux sont comme les instances de classes, créés par
l’intermédiaire de l’opérateur new tout en précisant la taille
désirée:
1 NomDuTableau = new Type [Taille
Exemple:
1 int T[]=new int[10];
ClubSDAD
Les tableaux
Les tableaux à plusieurs dimensions
Tableauxà plusieursdimensions
S’il s’agitd’un tableauàplusieursdimensionsonutilisela syntaxe
suivante:
1 Type NomDuTableau[][]...;
Dansle casd’un tableau d’objets, la création du tableaune
signifiepascelledesélémentsdutableau
Exemple:
1 String TS[]=newString[3];
2 TS[0]=new String("abc");
3 TS[1]=new String("defgh");
4 TS[2]=new String("ijk" );
ClubSDAD
Les classes Abstraites
.
LesclassesAbstraites
Une classe abstraite est une classe qui ne permet pas
d’instancier des objets,elle ne peut servir que de classe de
base pour une dérivation.
Dans une classe abstraite, on peut trouver classiquement des
méthodeset des champs, dont héritera toute classe dérivéeet
on peut trouver des méthodes dites « abstraites » qui
fournissent uniquement la signature et le type de retour
Syntaxe
ClubSDAD
Les classes Abstraites
Règles des classesabstraites
Dès qu’une classe abstraite comporte une ou plusieurs
méthodes abstraites, elle est abstraite, et ce même si l’on
n’indique pas le mot clé « abstract » devant sa déclaration.
Une méthodeabstraitedoit être obligatoirementdéclarée«
public », ce qui est logique puisque sa vacation est d’être
redéfiniedans une classe dérivée.
Les noms d’argumentsmuets doivent figurer dans la
définitiond’une méthodeabstraite
Une classe dérivée d’une classe abstraiten’est pas obligée
de redéfinir toutes les méthodes abstraites, elle peut ne
redéfinir aucune, mais elle reste abstraite tant qu’il y a
encore des méthodesabstraitesnon implémentées.
Une classe dérivée d’une classe non abstraitepeut être
déclaréeabstraite
ClubSDAD
Les classes Abstraites
EXEMPLE
ClubSDAD
Les interfaces
interface
Définition
Une interface définit un comportement (d’une classe) qui doit être
implémentépar une classe, sans implémenter ce comportement.C’est
un ensemble de méthodes abstraites, et de constantes. Certaines
interfaces( Cloneable, Serializable, …) sont dites interfaces de
«balisage» : elle n’imposent pas la définition d’une méthode, mais
indiquentque les objets qui les implémententont certainespropriétés.
Les différencesentre les interfaces et les classes abstraites :
Une interfacen’implémente aucuneméthode.
Une classe, ou une classe abstraite peut implémenter plusieurs
interfaces,mais n’a qu’une super classe, alors qu’une interfacepeut
dériver de plusieursautres interfaces.
Des classes non liéeshiérarchiquementpeuventimplémenterla
mêmeinterface
ClubSDAD
Les interfaces
L'interface Comparable
L’interface Comparable,nécessitel’implémentation de la
méthodecompareTo
Exemple:ordonner les employés d’une entreprise par ordre croissant
des salaires:
ClubSDAD
Les interface
L'interface Comparable
ClubSDAD
Les interfaces
L’interface Serializable
Lasérialisationd'unobjet est leprocessusdesauvegarded'unobjetcompletsur
fichier, d'où il pourra être restauré à tout moment. Leprocessus inverse de la
sauvegarde( restauration) estconnusouslenom dedésérialisation.
Touslesattributs (qui nesontpasspécifiéstransient) d’une classeimplémentant
l’interface Serializable sont sauvés et restaurés de façon simple en utilisant les
classesObjectOutputStreamet ObjectInputStream.
EX:
ClubSDAD
Les interfaces
L’interface Iterator
L’interface Iterator nécessitel’implémentation des
fonctions ha sNext(), next(),remove()
ClubSDAD
Les interfaces
InterfacesListlterator
L'interface ListIterator
L'interfaceListIterator est dérivée de Iterator, et ajoutedes fonctionnalités
de parcours dans le sens inverse, de calcul d’indice, et d’ajout et de
modification.
ClubSDAD
L’héritage enJava
Pourréaliserune nouvelle classeB qui hérited’uneclasseA existante,
la syntaxeutiliséeestla suivante :
1 class B extends A{
2 ...
3 }
Un objetdela classeB peutmaintenantappelerlesméthodes
publiquesde B et de A.
Si uneméthodeestdéfinieà la foisdansB etdansA (redéfinition),
alors celle invoquée par un objet de la classe B est la méthode
redéfinie dansla classe B.
ClubSDAD
Exempled’héritage
1 class Personne{
2 String nom ;
3 int nombreEnfants = 0 ;
4Personne(String n){
5 nom= n ; }
6 }
7 class Salarie extends Personne{
8 int salaire ;
9Salarie (String n, int s ) {
10 super (n) ;
11 salaire = s ; }
12 int prime (){
13float taux = nombreEnfants * 5 / 100 ; 14
return salaire * taux ;}
15}
ClubSDAD
L’attribut caché this
Chaqueinstance declassecomporteun attribut appeléthis qui
désignel’instancecourante de la classe.
Cette attribut peut être utile pour retourner une référencevers
l’instance ou pour lever certainesambiguïtéssur lesidentifiants.
Exemple
1 public float longueur;
2 public void fixeLongueur(float longueur){
3 this.longueur = longueur;
4 }
ClubSDAD
Mot clé super
Lemotclésuperdésignela classemère.Ilpeutêtreutilisédansdeux
situations différentes:
1
Pourappelerunconstructeurdelaclassemère: il estalorsutilisé
commepremièreinstructiondu constructeurdela classefille :
Syntaxe
1 super (paramètres du constructeur de la classe mère)
2
Pourappeleruneméthodede la classemère,si celle-ciestredéfinie
danslaclassefille :
Syntaxe
1 super.nomDeLaMethode (paramètres );
ClubSDAD
Exempled’appel d’un constructeur de la classe mère
Classe mère
1 class A{
2private string Name; 3
A(String S){ Name=S;}
4 String getName(){ return Name;}
5 }
Classefille
1 class B extends A {
2 B(String Name){ super(Nom);}
3public static void main(String [] args){ 4
B objet = new B("objet B");
5 System.out.println(B.getName());}}
ClubSDAD
Exempled’appel d’une méthodede la classe mère
Classe mère
p() de la classe A " );}
1 class A {
2 void p(){
3 System.out.println("Méthode
4 } }
Classefille
1 public class B extends A {
2 void p(){
3System.out.println("Méthode p() de la classe B " ); 4
super.p();}
5 public static void main(String [] args){
6 B objet = new B();
7 objet.p();}}
ClubSDAD
LespackagesenJava
Un packagecontientgénéralementplusieurs classes,qui sontdéfinies
généralementparplusieurs fichiers différents.
Chaquepaquetageporte un nom.
Cenom estsoit un simpleidentificateurou unesuited’identificateurs
séparéspar des points.
L’instructionpermettantdenommerun paquetagedoit figurerau
débutdu fichier source (.java).
On définitun packageparle mot réservépackage,suivi du nomdece
package,et d’un point-virgule.
1 package MonPackage;
2class ClasseA { ... int uneMethodeDeA(); ...} 3
class ClasseB { ... }
4 class ClasseC { ... }
ClubSDAD
Importation depackage
Le langagejavafournit unefacilitéd’écritureparl’emploi de la notion
d’importationde package.
Enutilisant lemotclefimport,onimportelesdéfinitionsunou
plusieurs élémentsd’un package.
Exemple
1 package Exemple;
2 class toto{ ...}
1 package Exemple;
2 class t i t i extends toto{ ...}
1 import Exemple.*;
2 class tutu extends t i t i {...}
ClubSDAD
Lesaspects objets du langage
Le langagejavaestun langageobjet qui proposeuneclassede base
appelée: java.lang.Object.
Touteslesclassesjava héritentimplicitementdejava.lang.Object.
Pourconnaîtrele typeréeld’un objeton utilisel’opérateur instanceof.
1
2
if ( objet instanceof maClasse )
// Bloc d’instructions
ClubSDAD
L’héritage et la classeObject
L’héritageest un concept qui esttoujoursutilisé en Java.
Ainsi àchaquefois que l’on définisse une nouvelle classe, celle-ci ce
dériveautomatiquementdela classeObjectmèredetoutesles classes.
1 class Test{
2 Test(){
3 String S=getClasse().getName();
4 System.out.println("Je suis un nouvel objet de la
classe :" + S);
5 }
6 public static void main(String args[]){
7 newTest();
8 }}
A l’exécutionle programmeaffichele message: Jesuisunnouvel
objet de la classe: Test
ClubSDAD
Lesméthodes dela classeObject
getClasse()étantuneméthodedela classeObjectretournantun objet
de type Class qui représentela classedel’objet appelant.
La méthodegetName()dela classeClasspermetd’obtenirle nomde
la classesousfromed’une chaînedecaractères.
protected Object clone() : créer une copie de l’objet appelant.
booleanequals(Objectobj) : testesi l’objet obj estégaleà l’objet
appelant.La fonctionretournetruesi lesobjetsont la même référence.
1 class1 v1= new class1 ();
2 class1 v2=v1;
3 if(v1.equals(v 2))...
La méthodeequalspeut êtreredéfiniepour faireunecomparaisonsur
le contenu et non la référence.
ClubSDAD
Lesméthodes dela classeObject
protectedvoidfinalize(): cetteméthodeestappeléeparle Garbage
Collectorlorsqu’ilveutéliminer un objetdela mémoire.
Si l’on veutréaliser un traitement particulieril suffitd’appeler et de
redéfinircetteméthodeaveclecomportement adéquat.
ClassgetClass(): retourneun objetdetypeClassqui représentela
classeà laquelle appartientl’objet appelant.
Pourafficherlenom decetteclasse,il suffitd’appeler la méthode
getName() sur l’objet retourné.
1 String S=getClasse().getName();
Pourcréerunnouvelobjetdecettemêmeclasse,onutiliselaméthode
newInstance().
1 Class c=getclasse();
2 try{ c.newInstance();
3 } catch (Exception e){ .... }
ClubSDAD
Lesméthodes dela classeObject
StringtoString(): retourneunereprésentationsousformeStringde
l’objet, affichableparl’intermédiaire dela méthode
system.out.print(ln).
La méthodetoString() estappeléeàchaquefoisquel’on essai
d’afficherunobjet parla méthode system.out.print(ln).
Il suffitdoncde la redéfinirdansla classedel’objet avecle
comportementadéquat.
Exemple
1 class Point{
2 int x, y;
3 ...
4 public String to String(){
5 return("("+x+ ", "+y+ ") ");}}
ClubSDAD
Lesclassesinternes
Lesclassesinternes(innerclasses)sontuneextensiondulangageJava
introduitedansla version 1.1 du JDK.
Cesont desclassesqui sontdéfiniesdansuneautre classe.
Lesdifficultésdansleurutilisation concernentleurvisibilitéet leur
accèsaux membresdela classedanslaquelleellessont définies.
1 public class ClassePrincipale {
2 public class ClasseInterne { ... }
3 }
Il estpossibled’imbriquer plusieurs classesinternesen Java.
1 public class ClassePrincipale {
2 public class ClasseInterne1 {
3 public class ClasseInterne2 {
4 public class ClasseInterne3 { ... }
5 } } }
ClubSDAD
Typesde classes internes
Il existe quatretypesdeclassesinternes :
lesclassesinternesnon statiques: ellessont membresà partentièrede
la classequi lesenglobeet peuventaccéderà touslesmembresde cette
dernière.
lesclassesinterneslocales: ellessontdéfiniesdansunblocdecode.
Ellespeuventêtre static ou non.
lesclassesinternesanonymes: ellessontdéfinieset instanciées à la
voléesansposséder de nom.
lesclasseinternesstatiques: ellessont membresà part entièredela
classe qui les englobe et peuvent accéderuniquement aux membres
statiquesdecettedernière.
ClubSDAD
Héritage d’une classeinterne
Uneclassepeuthériterd’uneclasseinterne.Dansce cas,
il fautobligatoirementfournir aux constructeurs dela classeune
référencesurla classeprincipaledela classemèreet
appelerexplicitementdansleconstructeurleconstructeurdecette
classeprincipaleavecunenotationparticulièredu motclé super.
1 public class ClassePrincipale{
2 public class ClasseInterne{ }
3 public class ClasseFille extends
ClassePrincipale.ClasseInterne{
4 public ClasseFille(ClassePrincipale cp) { cp. super();}}}
Uneclasseinternepeutêtredéclaréeavecfinal et abstract.
Aveclemodificateurfinal,la classeinterne ne pourraêtreutilisée
commeclassemère.
Aveclemodificateurabstract,laclasseinternedevraêtreétenduepour
pouvoirêtre instanciée.
ClubSDAD
Classesinternes anonymes
Lesclassesinternesanonymes(anonymousinner-classes) sontdes
classesinternes qui nepossèdentpasde nom.
Ellesnepeuventdoncêtreinstanciées qu’àl’endroit où ellessont
définies.
Une syntaxeparticulière del’opérateur newpermetdedéclarer et
instancierune classeinterne :
1 newclasse_ou_interface () {
2 // définition des attributs et des méthodes de la classe
interne
3 }
Une classeinterne anonyme peut soit hériter d’une classesoit
implémenteruneinterfacemaisellenepeut pasexplicitementfaireles
deux.
ClubSDAD
Classeinterne anonyme
Uneclasseinterneanonymenepeutpasavoirdeconstructeur
puisqu’elle nepossèdepasdenom mais elle peut avoir des
initialisateurs.
1 public void i n i t ( ) {
2 boutonQuitter.addActionListener(
3 new ActionListener() {
4 public void actionPerformed(ActionEvent e) {
5 System.exit(0);
6 }});
7 }
La classe interne anonyme ne pourra être instanciée dans le code qu’à
l’endroit où elle estdéfinie: elle estdéclaréeet instanciée enun seulet
uniqueendroit.
ClubSDAD
Classesinternes statiques
Lesclassesinternesstatiques(static memberinner-classes)sontdes
classes internes qui ne possèdent pas de référence vers leur classe
principale.
Ellesnepeuventdonc pasaccéderaux membresd’instance de leur
classeenglobante.
Ellespeuventtoutefoisavoiraccèsaux variablesstatiques dela classe
englobante.
Pourlesdéclarer,il suffitd’utiliserenpluslemodificateurstatic dansla
déclarationdela classeinterne.
1 public class ClassePrincipale{
2public static class ClasseInterne {
3 public void afficher() {
4 System.out.println("bonjour");}}
5public static void main(String[] args) { 6
new ClasseInterne().afficher();}}
ClubSDAD
Le traitement des exceptions en Java La gestion des exceptions
Exceptions en Java
Uneexceptionestuneerreurquiseproduitpendantl’exécutiond’un
programme.
Ce sontdesinstancesdeclassesdérivant de
1 java.lang.Exception
Elle peut conduire soit à l’arrêt du programmesoit à desrésultats
incorrects.
Lesexceptionspeuventêtregénérées
soit parl’environnementd’exécutionJava,par exemplemanquede
place mémoire,
soit à causedu non respectdesrèglesdu langageou
soit parlecode(exceptionsdéfiniesexplicitementpar lesutilisateurs).
ClubSDAD
Le traitement des exceptions en Java La gestion des exceptions
Gestion desexceptions
ClubSDAD
La gestion des exceptions
Attraper desexceptions système
Il estpossibled’attraper(capturer)l’exception, à l’aide du bloc«
try-catch»,afindegérercette exception.
1tr y { / / bloc du code décrivant l e déroulement normal du
programme e t les instructions de ce bloc sont
susceptibles de lever une exception
2 }
3 catch (ExceptionType1 objetTypeException) {
4 // Ce bloc constitue le gestionnaire de l’exception de
les instructions àtype ExceptionType1 et contient
exécuter en cas d’ erreur
5 }
6 catch (ExceptionType2 objetTypeException) {
7 // Ce bloc constitue le gestionnaire de l’exception de
les instructions àtype ExceptionType2 et contient
exécuter en cas d’erreur
8 }
Club SADA
Exemple1 (division par zéro)
Club SDAD
Bloc finally
finally c’estuneinstructionoptionnellequi estexécutéequellequesoit
le résultat du bloc try (c’est-à-dire qu’il ait déclenché ou non une
exception).
Elle permetdespécifierdu codedont l’exécution estgarantiequoi
qu’il arrive.
1 try {
2 . . .
3 }
4 catch ( . . . ) {
5 . . .
6 }
7 finally {
8 . . .
9 }
Club SDAD
Le traitement des exceptions en Java
La création d’exception personnalisée
Constructeursdes exceptions
La création d’exceptionpersonnaliséepeutêtreréaliséeenrajoutant
desconstructeurset desmembressupplémentaires.
Parconvention,touteslesexceptionsdoivent avoiraumoinsdeux
constructeurs:
un sansparamètre.
un autredont leparamètreestunechaînedecaractèresutiliséepour
décrirele problème.
1 public class MonException extends Exception {
2 public MonException(String text) { sup er(text); }}
On utilisele motcléthrowpour leveruneexceptioneninstanciant un
objetsuruneclassedérivéedela classeException.
1 throw new MonException("blabla");
Club SDAD
La création d’exception personnalisée
Constructeurset méthodesde la classe Throwable
Exception(): constructeursansargument.
Exception(String): ConstructeuravecArgument.
getMessage() : retourne le message d’erreur décrivant l’exception.
printStackTrace(): affichesurla sortiestandardla listedesappelsde
méthodesayantconduità l’exception.
Club SDAD
Les chaînes de caractères en Java
Les chaînes de caractères non modifiable
Leschaînes decaractères
Unechaînedecaractères (appeléeString)estune suite(uneséquence)
decaractères.
Longueur et accèsauxcaractèresd’unechaînedetypeString
String s1="bonjour";
String s2=""; / / chaîne vide
i n t n1=s1.length( ) ; / / n1 = 7
int n2=s2.length( ) ; / / n2 = 0
La méthodecharAt( ) dela classeStringpermetd’accéderàun caractère de rang
donnéd’une chaîne.
1 String s ="bonjour";
2char c1= s.charAt(0); / / c1=’b’
3 char c2= s.charAt(2); / / c2=’n’
Club SDAD
Les chaînes de caractères en Java
Les chaînes de caractères non modifiable
Déclaration et création
Strings; : déclarequesestuneréférenceà un objetde typeString.
Ici on a crééla référencemaispas l’objet.
Stringn’estpasun type primitif, pourcréerl’objet, on utilise
l’opérateurnew.
1 String s;
2 s =newString ("bonjour"); / / s contient la référence à un
objet contenant l a chaine "bonjour".
On peut regrouperlesdeuxinstructions :
1 String s=new String ("bonjour");
On peut aussiécrire toussimplement :
1 String s= "bonjour";
Club SDAD
Les chaînes de caractères en Java Les chaînes de caractères non modifiable
Caractéristiques
Un objet detype String n’est pasmodifiable:
Il n’existera aucuneméthodepermettantdemodifierle contenud’un
objetde type String.
Attention, l’affectationnemodifiel’objet.
1
2
3
String s;
s="bonjour";
s="bonsoir";
L’objet sn’a pasétémodifié,maisc’estlaréférencesqui aété
modifiée.
Aprèsaffectation,s référenceun autreobjet(la chaîne "bonsoir")
Club SDAD
Les chaînes de caractères en Java
Les chaînesde caractères non modifiable
Concaténation dechaînes
Laméthodeconcat()permetlaconcaténationdedeuxchînaesde
caractères.
1 String ch1= "le langage";
2 String ch2= "java";
3 String ch=ch1. concat( ch2); // ch contient " l e langage
java"
Pourla concaténation,onpeutaussiutiliser l’opérateur+ dela
manièresuivante: Soients1et s2deuxobjetsdetype String.
1 String s =s1+s2;
2 // équivalent à String s=s1.concat(s2);
Club SDAD :le s
Les chaînes de caractères en Java Les chaînes de caractères non modifiable
D'autre opération sur les chaines
LaméthodeindexOf()retournela positionde la premièreoccurrenced’uncaractèredans
unechaînede caractères.
La recherchecommenceà partirdu débutde la chaînes.Sion netrouvepasde
caractères,danslachanes,correspondantau caractèrech, elleretourne1.
Comparaisonsdesréférences
s1.equals(s2);retournetrue.
s1.equals(s3);retournetrue. s1et s2ont lemêmecontenumaisils référencent
deuxobjetsdifférents.
Remplacementdecaractères:Laméthodereplace()créeunenouvellechaîneen
remplaçanttouteslesoccurrencesd’un caractèredonnéparun autre.
Extractiondesouschaîne:Laméthodesubstring() permetd’extrairedesouschaîne
d’unechaînedecaractères.
Stringsubstring(int début); retourneun nouveauStringqui commenceaucaractère
d’indicedébutet allantjusqu’auderniercaractèredela chaîne s.
Conversionenmajusculeouenminuscule:La méthodetoLowerCase( ) créeunenouvelle
chaîneen remplaçanttouteslesmajusculesparleuréquivalenten minuscules.La méthode
toUpperCase( ) crée une nouvelle chaîne en remplaçant toutes les minuscules par leur équivalent en
majuscules.
Club SDAD
Introduction
Généricité et collections
Généricité
En POO, la généricité est un concept permettant de définir des
algorithmes (types de données et méthodes)identiquesqui peuvent
être utilisés sur de multiplestypes de données.
La généricité permet de paramétrer du code avec des typesde
données.
Exemple:ClassArrayList<T>dontle code est paramétré par un typeT
ClubSDAD
Généricitéet collections
Généricité
Classegénérique
Une classe générique est une classe comprenant une ou plusieurs
variables de type = une classe paramétrée, dont le paramètre est un
type d'objet
Exemple:
public class Paire<T>{
private T premier;
privateT deuxième;
public Paire() { premier=null; deuxième=null;}
public Paire(T premier, T deuxième) {
this.premier=premier;
this.deuxième=deuxième;}
public T getPremier(){return this.premier;}
public void setPremier(T premier) { this.premier= premier;}
public T getDeuxième() {return this.deuxième;}
public void setDeuxième(T deuxième){this.deuxième= deuxième;
}
ClubSDAD
Généricitéet collections
Généricité
Classegénérique
La classe Paire introduitune variable de type T, incluse entre <>
après le nom de la classe
Une classe générique (paramétrée)peut posséderplusieurs
variables de type<T1,T2,T3,….>
Les variables de type peuvent être utilisées tout au long de la
définition de la classe pour spécifier le type de retour des méthodes,
le type des attributs, ou même le type de certaines variables locales
rien n'empêche également d'utiliser des attributs ou d'autres
éléments avec des types bien définis,c'est-à-dire nonparamétrable,
comme int, String,etc
Utilisation de la classegénérique:
-L'attributpremierutiliseunevariabledetype
-Ainsi,commesonnoml'indiquepremierpourraêtreden'importequel
type
-C'est celui qui utilisera cette classe qui spécifiera le type qu'il désire
utiliser pour décrire l'objet de cette classe Paire
ClubSDAD
Généricitéet collections
Généricité
Classegénérique
Utilisationde la classe générique:
Par exemple:
Paire<String>ordre;
Ici, ordre est un objet de type Paire<String>Le paramètre de la classe
Paire, ou exprimé autrement, la variable de type est String Ainsi, au
moment de cette déclaration,à l'intérieur de la classe Paire, tout ce qui
faitréférence à T est remplacé par le véritable type, c'est-à-direString.
public class Paire {private String premier ; private String deuxième;
public Paire(){ premier=null;deuxième=null;}
public Paire(String premier, String deuxième) {
this.premier=premier;this.deuxième=deuxième;}
public StringgetPremier(){return this.premier;}
public void setPremier(String premier) { this.premier = premier;}
public StringgetDeuxième(){return this.deuxième;}
public void setDeuxième(Stringdeuxième) {this.deuxième =
deuxième;}}
ClubSDAD
Généricitéet collections
Généricité
Classegénérique
Le code qui utilise la généricité a de nombreux avantagesparrapport
au code non générique:Contrôlesde type plus forts au moment dela
compilation. Un compilateur Java appliqueun contrôlede type fort au
code générique et émet des erreurs si le code enfreint la sécurité au
niveau de typage. Il est plus facile de corriger les erreurs de
compilation au lieu de corriger les erreurs d’exécution, ce qui peut
être difficile à trouver.
ClubSDAD
Généricitéet collections
Généricité
Variabledetype
Par convention, les noms de paramètre de type générique sont
des lettres simples majuscules. Pour une bonne raison: sans
cette convention,il serait difficile de faire la différence entreune
variable de type et un nom de classe ou d’interface.
Les noms de paramètre de type générique les pluscouramment
utilisés sont:
T:est utilisé pour qu’une classe génériquerenvoie et accepte
n’importequel typed’objet
N:est utilisé pour qu’une classe génériquerenvoie et accepte un
nombre
.
ClubSDAD
Généricitéet collections
Généricité
Méthodegénérique
Les méthodes sur java vont nous permettre de créer desalgorithmes
de code que nous allons pouvoir faire appel quand on en a besoin.
ClubSDAD
Les méthodes génériques sont celles qui sont écrites avec uneseule
déclaration et qui peuvent être appelées avec des arguments de
différentstypes.
En fonctiondes types d’argumentspassésà la méthode générique,le
compilateur gère chaque appel de méthode de manièreappropriée.
Généricitéet collections
Généricité
Méthodegénérique
Syntaxe d’une méthode générique
Les méthodes génériques ont un type paramétré(<T>)avantle typede
retour de la déclaration de méthode.
Les méthodes génériques peuvent avoir différents types paramétrés
séparés par des virgules dans la signature de méthode : <T1,T2,…>
Le corps d’une méthodegénériqueest comme une méthodenormale
Appel de la méthode générique
On peut appelerune méthode paramétréeen la préfixantpar le(ou
les) type qui doit remplacer le paramètre de type.(<T>)
ClubSDAD
Généricitéet collections
Généricité
Méthode générique
ClubSDAD
Généricitéet collections
Généricité
Interfacegénérique
Les interfacesgénériques ont les mêmes objectifs que lesinterfaces
régulières. Ils sont soit créés pour exposerles membres d'uneclasse
qui seront utilisés par d'autres classes, soit pour forcer une classe à
implémenter des fonctionnalitésspécifique.
=>Alors la généricité fonctionne également avec lesinterfaces.
Syntaxe d’une interfacegénérique
Les interfaces génériques ont un type paramétré(<T>)après le nomde
l’interface.
Les interfacesgénériques peuvent avoir différentstypesparamétrés
séparés par des virgules : <T1,T2,…>
Le corps d’une interface générique est comme une interface
normale (Toutes les méthodes d'une interfacesontimplicitement
abstraites).
ClubSDAD
Généricitéet collections
Généricité
Interfacegénérique
Déclaration des interfacesgénérique
Les interfacesgénériques sont déclarées comme desclasses
génériques. Par exemple :
Implémentation des interfacesgénériques
public class GenericClass<E> implements GenericInterface<E>
RQ: Une classe générique peut également avoir d'autresparamètresen
dehors du paramètre de type qu'elle doit utiliser en raison de
l'implémentationd'une interface générique.
public class GenericClass<K,V, E> implements GenericInterface<E>
ClubSDAD
Généricitéet collections
Généricité
Interfacegénérique
ClubSDAD
Généricitéet collections
Généricité
Interfacegénérique
ClubSDAD
Généricitéet collections
Généricité
Diamant
Dans java SE 7 et ultérieur l’argument type peut être remplacé par un
ensemble vide d’arguments de type (<>) appelé le diamant (Diamond)
Version >= java SE 7
Pour instancier une classe générique on écrit:
Avec le diamant : Paire<Integer>P1= new Paire<> ();
Avec les anciens versions :Paire<Integer> P1= new Paire<Integer> ();
La seule limite du diamant est si on l’utilise avec les classes anonymes
ClubSDAD
Généricitéet collections
Généricité
Diamant
ClubSDAD
Généricitéet collections
Généricité
ExtendsA&B
On sait bien que l’Héritage multiple n’est pas autorisé dans java mais
il y a une solution qui collectionne entre la généricité ,l’héritage et les
interfaces.
public interfaceLiquide{…}
public class Jus{…}
public class TestJus<T extends Jus & Liquide>{}
On a le droit d’instancier la classe TestJusà condition que
T doit être une classe qui hérite de Jus et implémente
Liquide
public class JusOrange extends Jus implementsLiquide{}
TestJus<JusOrange>G1=new TestJus< JusOrange>();
ClubSDAD
Généricitéet collections
Généricité
ExtendsA& B
ClubSDAD
collections
Définition
Une collectionest un objet dont la principale fonctionnalité est de
contenir d’autresobjets,comme untableau.
Le JDK fournit d’autrestypes de collectionssous la forme de classes
et d’interfaces.
Ces classes et interfaces sont dans le paquetagejava.util.
Plusieurs types de collectionsproposés:
List : Collection ordonnée, aussi appelée séquence.
Queue : Collection pourla gestion d’éléments avant leur traitement.
Exemple : file d’attente LIFO, FIFO ou avec un tridéfini.
Set : ensemble d’élément non ordonné,un élémentpeut être présent
une ou plusieurs fois selon les mises en œuvre.
SortedSet : Ensemble d’éléments triés selon un tri défini.
Tous imports de ce chapitresont dejava.util.*;
Généricité et collections
ClubSDAD
Généricité et collections
collections
Hiérarchie desinterfaces
Des interfaces dans deux hiérarchies d’héritage principales :
Collection<E> : correspond aux interfaces des collections
proprement
dites.
Map<K,V> : correspond aux collectionsindexées par des clés; un
élément de type V d’une map est retrouvé rapidement si on
connaîtsa clé de type K (comme les entréesde l’index d’un livre).
Les collectionsJava contiennentdes éléments de type Object.
ClubSDAD
Généricité et collections
collections
s
List:ArrayList
Pas de limite de taille
Possibilité de stocker tout type de données (y compris null )
Pour créer un ArrayList:
ArrayList list = newArrayList();
Pour ajouter la valeur 3 a la liste :
list.add(3);
Pour récupérer la taille de la liste:
System.out.println(list.size());
Pour récupérer un élément de la liste
System.out.println(list.get(indice))
ClubSDAD
Généricité et collections
Collections
List:LinkedList
C’est une liste dont chaque élément a deux référerences :
une vers l’élément précédent et la deuxièmevers l’élément
suivant.
Pour le premierélément, l’élément précédentvaut null
Pour le dernierélément,l’élément suivant vaut null
addFirst(object) : insère l’élément object au début de la liste
addLast(object) : insère l’élément Object comme dernier
élément de la liste (exactement comme add())
4
ClubSDAD
Map:Hashtable
Un HashTableest une implémentation de Map qui associe une clé à
une valeur. N'importequel objet, mis à part null peut y êtreajouté.
Voici un exemple d'utilisation de HashTable, où on associe un
numéro de mois à son nom:
Map monHashtable = new Hashtable() ;
monHashtable.put(newInteger(1),"Janvier");
monHashtable.put(new Integer(2),"Fevrier");
monHashtable.put(new Integer(3),"Mars");
monHashtable.put(new Integer(4),"Avril");
monHashtable.put(new Integer(5),"Mai");
monHashtable.put(newInteger(6),"Juin");
Généricité et collections
collections
collections
ClubSDAD
collections
Généricité et collections
Map:HashMap
Un HashMap est une collection similaire au HashTable. Seules deux
choses les diffèrent : HashMap accepte comme clé et comme valeur
null
HashMap<String,Integer> map = newHashMap<>();
// Ajouter leséléments
map.put(«ALi", 2);//Combiende Ali on a dans la classe
map.put(« Ahmed",3);
map.put(«Fatima",5);
ClubSDAD
Set:HashSet
HashSet est l'implémentation la plus utile de Set. Elle permet de
stocker des objets sans doublons,des exceptionssont levées si l'on
essaie d'insérer un objet non autorisé (comme null). Cependant, si
l'on essaie d'ajouter un objet déjà présent, la fonction add renverra
tout simplement false et ne fera rien. Pour parcourir un HashSet
Set monHashSet=new HashSet(); // on crée notre Set
monHashSet.add(newString("1"));// on ajoute des string quelconques
monHashSet.add(newString("2"));
monHashSet.add(newString("3"));
Généricité et collections
collections
ClubSDAD
Création des Threads en Java Présentation des Threads en Java
Présentation desprocessus &Threads
Processus: est unprogrammequi s'exécute et quipossède son
propreespacemémoire:sesregistres,sespiles,sesvariableset
sonpropreprocesseurvirtuel
Thread : Les threads Java sont des processus légers : ils
partagentun ensembledecodes,donnéesetressourcesausein
d’un processuslourd qui leshéberge(ce processusest laJVM).
Avantagesdesprocessuslégersparrapportauxprocessussystème:
rapiditéde lancementet d’exécution;
partagedesressourcessystèmedu processusenglobant;
simplicité d’utilisation.
Club SDAD
Création des Threads en Java
Présentation des Threads en Java
Création desthreads
Ils existe deuxméthodespour créerunThreaden Java :
La premièreméthodeconsisteà étendrela classeThreaddu package
java.langet à redéfinirsa méthode run().
La deuxième méthode consiste àimplémenter l’interface Runable par
l’intermédiairedesa méthoderun() et decréerun Threadà basedela
nouvelle classe.
La classejava.lang.Threadet l’interface java.lang.Runnablesontles
basespour le développementdesthreadsen java.
Parexemple,pourexécuterdesappletsdansunthread,il fautque
cellesci implémententl’interface Runnable.
Club SDAD
Création des Threads en Java Création par extension de la classe Thread
Créationd’un thread par extensiondela classeThread
LaclasseThreadoffrelapossibilitédecréerunprocessusquise
termineimmédiatementaprèssa création.
carla méthoderun() exécutéepar le processus dèsqu’il estcrééest
définievidedanslaclasseThread.
Pourpersonnaliserle comportementdesprocessusà créer,il suffit donc
d’étendrela classeThreadavecredéfinitiondela méthode run().
Ensuite, la création d’un processus revient à instancier un objet
Threadetàlefairedémarrercommeprocessusàl’aidedelaméthode
start() définie dansla classe Thread.
Celle-cicréeleprocessuset appelleautomatiquementla méthode run().
Club SDAD
Création des Threads en Java Création par extension de la classe Thread
Exemple
Club SDAD
Création des Threads en Java
Création par extension de la classe Thread
Remarques
La créationd’un objetProcessusn’implique pasla créationdu thread.
Le processus doit être crééexplicitement par un appel àla méthode
start() surl’objet créé;celle-ci réalisedeuxtâches principales :
La premièretâcheconsisteà fairedémarrerleprocessusentant que
processus.
La deuxièmetâcheconsisteà appelerla méthoderun().
Appelerla méthoderun() à la placedestart() nefait pasdémarrerle
processus, mais exécute tout simplement la procédure run() de la
classeProcessus.
La classe Thread dispose de 8 constructeurs dont l’un est un
constructeurà un paramètredetypeStringpermettantd’affecterun
nomau processuscréé:
1 public Thread (String name)
Club SDAD
Création des Threads en Java
Création par implémentation de l’interface Runnable
Création d’un thread par implémentation de l’interface
Runnable
Un threadpeutêtrecrééparimplémentationde l’interfaceRunnable
du packagejava.lang. Ceci est réalisé par l’intermédiaire de l’un des
deuxconstructeurssuivantsquireçoiventenparamètreunobjet d’une
classequi implémentel’interfaceRunnable :
1 public Thread(Runnable target)
2 public Thread(Runnable target, String name)
L’interfaceRunnabledéclareuneseuleméthode« run() » quela
classedel’objet ‘target’ doit implémenter.
La méthoderun() seraalors exécutéepar lethreadcréé.
NoterquepourfaireréférenceauThreadencoursd’exécution au sein
desméthodes de votre classeimplémentant Runnable ; on utilise la
méthodestatiqueThread.currentThread().
Club SDAD
Création des Threads en Java
Création par implémentation de l’interface Runnable
Création d’un processus
La créationd’un processuspassepardeuxétapes:
La premièreétapeconsisteà implémenterl’interfaceRunnable:
1
2
class Traitement implements Runnable{
Public void run(){ // comportement du
processus
}
}
3
4
La 2èmeétapeconsisteà créerun threadà based’un objetdela classe
précédente:
1
2
3
Traitement tr=new Traitement();
Tread P=new Thread ( t r , "Nom");
P. start();
Club SDAD
Les moniteurs et gestion des priorités Les moniteurs
Moniteur et ressource
Uneressourcecritiqueestuneressourcequi nedoit êtreaccédéeque
parun seulthreadà la fois.
En Java, il n’est pas possible de contrôler directement l’accès simultané
à une variable, il faut l’encapsuler et contrôler l’exécution de l’accesseur
correspondant.
Un moniteurestun verrouqui nelaissequ’un seulthreadà la fois
accéderà la ressource.
En Java,tout objetpeutjouerle rôledemoniteur.Onposeun
moniteursurun blocdecodeà l’aide du mot clé synchronized.
1 synchronized(objetMonitor){
2 ... //code en section critique
3 }
8Club SDAD
Les moniteurs et gestion des priorités Les moniteurs
Exemple
Club SDAD
Les moniteurs et gestion des priorités
Les moniteurs
Exemple(suite)
Club SDAD
Les moniteurs et gestion des priorités Les moniteurs
Synchronisation desméthodes
Lesméthodesbénéficierdelasynchronisation, afind’éviterque
plusieursthreadsn’y accèdentenmêmetemps.
SiuneclasseClass1disposed’une méthodeparexemple:voidsc()qui
doit êtreexécutéenexclusion mutuelle.
Celle-cidoit alorsêtreinséréedansun moniteurpar l’intermédiairedu
modificateursynchronizeddela manièresuivante:
1 Class Class1{
2 ...
3 synchronized void sc(){... }
4 ... }
Si un processusestalorsentrain d’exécuter la méthodesc()surun
objetm( m.sc()),aucunautreprocessusn’auraledroit d’exécuterla
mêmeprocédure sur le mêmeobjet m jusqu’à ceque le premier
processusquittela méthode.
Club SDAD