Université Sidi Mohammed Ben Abdellah

Faculté des Sciences Dhar Mehraz

Département d’Informatique
SMI/S5

Programmation Orientée Objet sous Java

Pr. Ismail EL BATTEOUI

SMI/S5
1
A.U:2022/2023
Chapitre 5: Héritage (suite)
❑Classe Object:
❖ La classe Object est une classe dont ❖ Exemple:
dérive implicitement toute classe simple. Point p = new Point (...) ;
❖ Exemple: Point3D p3d = new Point3D (...) ;
class A{ Homme h = new Homme (...) ;
……… Object o ;
} .....
est équivalent à: o = p ; // OK
o = p3d ; // OK
class A extends Object{ o = h ; // OK
……… ❖ Cette classe peut être utilisée pour
} déclarer des objets dont on ne connaît
❖ Référence de type Object: pas le type exact .
▪ Une variable de type Object peut être ❖ L’appel d’une méthode par à un objet
utilisée pour référencer un objet de référencé par une variable de type
type quelconque : Object nécessitera d’effectuer une
SMI/S5 A.U:2022/2023
conversion adéquate. 2
Chapitre 5: Héritage (suite)
❑Classe Object:
❖ Exemple:
Point p1 = new Point (...) ;
Object o ;
o = p1 ;
o.affiche() ; // erreur de compilation
((Point)o).affiche() ; // OK
Point p2 = (Point) o ; // OK
p2.affiche() ;
❖ méthodes de la classe Object:
▪ Les méthodes de la classe Object
peuvent être utilisées telles quelles ou
redéfinies.
▪ Les méthodes les plus utilisées sont:
SMI/S5 A.U:2022/2023
public class Object{
public String toString() {……..}
public final Class getClass() {……}
public boolean equals(Object o)
{………}
protected Object clone() throws
CloneNotSupportedException
{…..}
………..}
❖ Exercices:
▪ Redéfinir la méthode toString de Point.
▪ Redéfinir la méthode equals dans Point.
▪ Définir une méthode afficheNom qui affiche le
nom de la classe d’un objet Point.
3
Chapitre 6: Interfaces
❑Interfaces:
❖ Une interface est une classe abstraite avec
champs constants (static ou final) et dont
toutes les méthodes sont abstraites (sauf
une seule depuis Java 1.8).
❖ Le langage JAVA ne permet pas l'héritage
multiple mais une classe peut ‘’hériter’’
de plusieurs interfaces.
❖ Ainsi pour ajouter de nouvelles
fonctionnalité à une classe qui hérite déjà
d'une classe, la seule solution est que cette
classe implémente une interface.
❖ Pour une interface, on ne parle pas d'
héritage mais d'implémentation.
❖Déclaration d’une interface:
public abstract interface UneInterface {
public abstract String methode1(String s);
public abstract int methode2(double d);
}
❖ Utilisation:
public class A implements UneInterface {
….
}
Ou
public class A extends B implements
UneInterface, UneAutreInterface {…..}
❖ Exercice:

SMI/S5 A.U:2022/2023 4
Chapitre 7: Exceptions
❑Gestion des exceptions:
❖ une exception est une rupture d’exécution ❖ Le choix du bon gestionnaire est fait en
déclenchée par une instruction (throw) fonction du type de l’objet mentionné à
comportant une expression de type classe. throw.
❖ Java dispose donc d’un mécanisme très ❖ Exemple:
souple nommé gestion d’exception, qui class Point{
permet à la fois : public Point(int x, int y) throws AttrExcep
▪ de dissocier la détection d’une anomalie { if ( (x<0) || (y<0)) throw new AttrExcep() ;
de son traitement. this.x = x ; this.y = y ;}
▪ de séparer la gestion des anomalies du public void affiche(){
reste du code, donc de contribuer à la System.out.println ("coordonnees : " + x + "
lisibilité des programmes. " + y) ;}
❖ Il y a alors branchement à un ensemble private int x, y ;}
d’instructions nommé gestionnaire class AttrExcep extends Exception{ }
d’exception .

5
SMI/S5 A.U:2022/2023
Chapitre 7: Exceptions
❑Gestion des exceptions:
❑ Gestionnaire d’exception: ▪ faire suivre ce bloc de la définition des
❖ Pour gérer convenablement les éventuelles différents gestionnaires d’exception par
exceptions de type AttrExcep pouvant le mot clé catch.
déclencher, il faut : Exemple:
▪ inclure dans un bloc particulier dit bloc catch (AttrExcep e)
try les instructions dans lesquelles on { System.out.println ("Erreur") ;
risque de voir déclenchée une telle System.exit (-1) ;
exception ; un tel bloc se présente ainsi : }
try D’où: try
{ {
// instructions // instructions
} }
catch (AttrExcep e){
System.out.println ("Erreur") ;
}
6
SMI/S5 A.U:2022/2023
Chapitre 7: Exceptions
❑Gestion des exceptions:
class Point{ public class Test1{
public Point(int x, int y) throws AttrExcep public static void main (String args[]){
{ if ( (x<0) || (y<0)) throw new AttrExcep() ; try{
this.x = x ; this.y = y ; Point a = new Point (1, 4) ;
} a.affiche() ;
public void affiche(){ a = new Point (-3, 5) ;
System.out.println ("coordonnees : " + x + " " a.affiche() ;
+ y) ; }
} catch (AttrExcep e){
private int x, y ; System.out.println ("Erreur ") ;
} }
class AttrExcep extends Exception }
{} }

7
SMI/S5 A.U:2022/2023
Chapitre 7: Exceptions
❑Gestion des exceptions:
❑ Gestion de plusieurs exceptions class AttrExcep extends Exception{ }
class Point{ class DepExcep extends Exception{ }
public Point(int x, int y) throws AttrExce{ public class Test2{
if ( (x<0) || (y<0)) throw new AttrExcep() ; public static void main (String args[]){
this.x = x ; this.y = y ; try{
} Point a = new Point (1, 4) ;
public void deplace (int dx, int dy) throws a.affiche() ;
DepExcep{ a.deplace (-3, 5) ;
if ( ((x+dx)<0) || ((y+dy)<0)) throw new a = new Point (-3, 5) ;
DepExcep() ; a.affiche() ;
x += dx ; y += dy ; }
} catch (AttrExcep e){
public void affiche(){ System.out.println ("Erreur ") ;
System.out.println ("coordonnees : " + x + " " }
+ y) ;} private int x, y ;} catch (DepExcep e)
SMI/S5 A.U:2022/2023
{ System.out.println ("Erreur encore 8 ") ;
Chapitre 7: Exceptions
❑Gestion des exceptions:
❑ Transmission d’information au class Point{
public Point(int x, int y) throws AttrExcep{
gestionnaire d’exception: if ( (x<0) || (y<0)) throw new AttrExcep("Erreur" ) ;
❖ on peut se contenter de transmettre un this.x = x ; this.y = y ;
message au gestionnaire, sous forme }
public void affiche(){
d’une information de type chaîne en System.out.println ("coordonnees : " + x + " " + y) ;
exploitant le constructeur à un argument }
de type String de la classe Exception. private int x, y ;
}
❖ Pour récupérer la valeur de ce message, class AttrExcep extends Exception{
on utilise la méthode getMessage. AttrExcep (String message){
super(mes) ;
}
}
........
catch (AttrExcep e)
{ System.out.println (e.getMessage()) ;
}
9
SMI/S5 A.U:2022/2023
Chapitre 7: Exceptions
❑Gestion des exceptions:
❖ Clause throws:
▪ Toute méthode susceptible de déclencher
une exception qu’elle ne traite pas
localement doit indiquer son type à l’aide
de la clause throws et ce dans son en-tête.
❖ Bloc finally:
▪ Le déclenchement d’une exception
provoque un branchement inconditionnel
au gestionnaire convenable.
▪ L’exécution se poursuit avec les
instructions qui suivent ce gestionnaire.
▪ Pour forcer l’exécution toujours d’un bloc
d’instructions qui suit try…catch (quand
bien sur le bloc try s’exécute), on peut
utiliser le mot clé finally et ce après le
dernier
SMI/S5
gestionnaire. A.U:2022/2023
❖ Exceptions standards
▪ Java dispose de plusieurs exceptions
implicites ou hors contrôle qui n’ont pas
à être mentionnées dans une clause
throw et on n’est pas obligé de les
traiter.
▪ IOException: et ses dérivées sont
utilisées par les méthodes d’entrées-
sorties.
▪ ArrayIndexOutOfBoundException:
indice de tableau hors limites, utilisée
par la JVM.
▪ NegativeArraySizeException:: taille de tableau
négative, utilisée par JVM.
▪ printStackTrace(): présente la succession des
différents appels ayant conduit à la méthode
10
coupable.
Chapitre 8: Collections
❑Introduction:
❖ Définition: ▪ Il existe deux hiérarchies de classes :
▪ Les collections Java sont un ensemble de o Des collections permettant de
classes définissant des structures de stocker des collections qui sont filles
données efficaces pour stocker, rechercher de l’interface Collection<Type>.
et manipuler des objets. o Des dictionnaires associatifs
▪ De nombreuses structures existent : contenant des couples clé/valeur qui
o Séquences :List sont filles de l’interface Map<k,v>.
o Ensembles : Set
o Dictionnaires: Map
❖ Organisation
▪ Ces différents types de données abstraits
sont spécifiés dans des interfaces de haut
niveau, puis implantés dans différentes
classes concrètes.

11
SMI/S5 A.U:2022/2023
Chapitre 8: Collections
❑Introduction:
❖ Parcours d'une collection :
▪ les collections possèdent un point
commun : le parcours de leur contenu.
▪ Le parcours, séquentiellement, des
éléments d’une collection est basé sur la
notion d’itération.
▪ Toute collection possède une méthode
Iterator<Type> iterator() qui retourne ❖ Utilisation d’une collection:
un itérateur permettant d'accéder aux
éléments un par un en avançant dans la
collection.
▪ Initialement, l'itérateur est placé avant le while (iterator.hasNext()){
premier élément.
▪ Les deux méthodes principales d'un
itérateur sont :
SMI/S5
o public boolean hasNext(): retourne true
s’il reste des éléments dans l’itération.
o public Type next(): retourne le prochain
élément et avance dans l’itération, s’il
n’y a plus d’éléments une exception de
type NoSuchElementException est
levée.
Collection<Type> collection=new……;
Iterator<Type> iterator=collection.iterator();
//tant qu’il reste des éléments, récupére le prochain
élément et avance.
Type t=iterator.next();
………………
}
12
A.U:2022/2023
Chapitre 8: Collections
❑Interface List:
❖ Les séquences:List ▪ remove(index).
▪ L’interface List<T> définit une séquence ❖ LinkedList<T>: basée sur une liste
d’éléments d’un index allant de 0 à doublement chainée.
size()-1. ▪ add(valeur):ajout en fin.
▪ On peut insérer des éléments au début, à ▪ addFirst(valeur);
la fin ou à une position donnée. ▪ get(index): récupérer une valeur d’un
▪ Les deux principales classes de l’interface indice donné.
List<T> sont ArrayList<T> et ▪ remove(index).
LinkedList<T>. ❖ Dictionnaire: Map
❖ ArrayList<T>:basée sur un Tableau de ▪ L’interface Map<K,V> spécifie une
taille variable. association entre une clé de type K et
▪ add(valeur):ajout en fin. une valeur de type V.
▪ set( index, valeur):ajout à une position ▪ Un Map ne peut pas contenir des clés
donnée. identiques.
▪ get(index): récupérer une valeur d’un ▪ Chaque clé n’est associée qu’à une et
13
indice donné.
SMI/S5 A.U:2022/2023
une seule valeur.
Chapitre 8: Collections
❑Interface Map:
❖ Dictionnaire:Map (suite)
▪ Les méthodes principales sont:
o L’ajout d’un couple: put(K k , V v).
o L’accés à une valeur via sa clé
V get(K k).
o Recherche de clé ou de valeur.
o Suppression d’une valeur.
▪ L’interface SortedMap<K,V> étend
Map<K,V> en rajoutant une relation
d’ordre sur les clés d’un dictionnaires.
▪ Classes principales:
o HashMap<K,V>:table avec hachage
sur les clés.
o TreeMap<K,V>: ensemble ordonné
sur les clés.
SMI/S5 A.U:2022/2023
❖ Parcours:
▪ Pour parcourir un Map, trois méthodes
peuvent être utilisées.
▪ Ces méthodes retournent les clés ou/et
les valeurs dans des collections (qui
peuvent être itérées).
o Collection values(): retourne une
collection contenant toutes les
valeurs.
o Set<K> keySet(): retourne un
ensemble contenant toutes les clés.
o Set<Map.Entry<K,V>> entrySet():
retourne un ensemble de tous les
couples (clé,valeur).
o Entry<K,V>: une classe interne de Map a
deux méthode getKey() et getValue(). 14