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: public class Object{
Point p1 = new Point (...) ; public String toString() {……..}
Object o ; public final Class getClass() {……}
o = p1 ; public boolean equals(Object o)
o.affiche() ; // erreur de compilation {………}
((Point)o).affiche() ; // OK protected Object clone() throws
Point p2 = (Point) o ; // OK CloneNotSupportedException
p2.affiche() ; {…..}
❖ méthodes de la classe Object: ………..}
▪ Les méthodes de la classe Object ❖ Exercices:
peuvent être utilisées telles quelles ou ▪ Redéfinir la méthode toString de Point.
▪ Redéfinir la méthode equals dans Point.
redéfinies. ▪ Définir une méthode afficheNom qui affiche le
▪ Les méthodes les plus utilisées sont: nom de la classe d’un objet Point.

SMI/S5 A.U:2022/2023 3
Chapitre 6: Interfaces
❑Interfaces:
❖ Une interface est une classe abstraite avec ❖Déclaration d’une interface:
champs constants (static ou final) et dont public abstract interface UneInterface {
toutes les méthodes sont abstraites (sauf public abstract String methode1(String s);
une seule depuis Java 1.8). public abstract int methode2(double d);
❖ Le langage JAVA ne permet pas l'héritage }
multiple mais une classe peut ‘’hériter’’ ❖ Utilisation:
de plusieurs interfaces. public class A implements UneInterface {
❖ Ainsi pour ajouter de nouvelles ….
fonctionnalité à une classe qui hérite déjà }
d'une classe, la seule solution est que cette Ou
classe implémente une interface. public class A extends B implements
❖ Pour une interface, on ne parle pas d' UneInterface, UneAutreInterface {…..}
héritage mais d'implémentation. ❖ 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: ❖ Exceptions standards
▪ Toute méthode susceptible de déclencher ▪ Java dispose de plusieurs exceptions
une exception qu’elle ne traite pas implicites ou hors contrôle qui n’ont pas
localement doit indiquer son type à l’aide à être mentionnées dans une clause
de la clause throws et ce dans son en-tête. throw et on n’est pas obligé de les
❖ Bloc finally: traiter.
▪ Le déclenchement d’une exception ▪ IOException: et ses dérivées sont
provoque un branchement inconditionnel utilisées par les méthodes d’entrées-
au gestionnaire convenable. sorties.
▪ L’exécution se poursuit avec les ▪ ArrayIndexOutOfBoundException:
instructions qui suivent ce gestionnaire. indice de tableau hors limites, utilisée
▪ Pour forcer l’exécution toujours d’un bloc par la JVM.
d’instructions qui suit try…catch (quand ▪ NegativeArraySizeException:: taille de tableau
négative, utilisée par JVM.
bien sur le bloc try s’exécute), on peut ▪ printStackTrace(): présente la succession des
utiliser le mot clé finally et ce après le différents appels ayant conduit à la méthode
10
dernier
SMI/S5
gestionnaire. A.U:2022/2023 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 : o public boolean hasNext(): retourne true
▪ les collections possèdent un point s’il reste des éléments dans l’itération.
commun : le parcours de leur contenu. o public Type next(): retourne le prochain
▪ Le parcours, séquentiellement, des élément et avance dans l’itération, s’il
éléments d’une collection est basé sur la n’y a plus d’éléments une exception de
notion d’itération. type NoSuchElementException est
▪ Toute collection possède une méthode levée.
Iterator<Type> iterator() qui retourne ❖ Utilisation d’une collection:
un itérateur permettant d'accéder aux Collection<Type> collection=new……;
éléments un par un en avançant dans la Iterator<Type> iterator=collection.iterator();
collection. //tant qu’il reste des éléments, récupére le prochain
élément et avance.
▪ Initialement, l'itérateur est placé avant le while (iterator.hasNext()){
premier élément. Type t=iterator.next();
▪ Les deux méthodes principales d'un ………………
itérateur sont : }
12
SMI/S5 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) ❖ Parcours:
▪ Les méthodes principales sont: ▪ Pour parcourir un Map, trois méthodes
o L’ajout d’un couple: put(K k , V v). peuvent être utilisées.
o L’accés à une valeur via sa clé ▪ Ces méthodes retournent les clés ou/et
V get(K k). les valeurs dans des collections (qui
o Recherche de clé ou de valeur. peuvent être itérées).
o Suppression d’une valeur. o Collection values(): retourne une
▪ L’interface SortedMap<K,V> étend collection contenant toutes les
Map<K,V> en rajoutant une relation valeurs.
d’ordre sur les clés d’un dictionnaires. o Set<K> keySet(): retourne un
▪ Classes principales: ensemble contenant toutes les clés.
o HashMap<K,V>:table avec hachage o Set<Map.Entry<K,V>> entrySet():
sur les clés. retourne un ensemble de tous les
o TreeMap<K,V>: ensemble ordonné couples (clé,valeur).
sur les clés. o Entry<K,V>: une classe interne de Map a
deux méthode getKey() et getValue(). 14
SMI/S5 A.U:2022/2023