{

Programmation
Orientée Objet 2
2ème année Ingénieurs informatique
Dr Souad Saighi

... }
 Présentation

{ Dr Souad Marir Saighi

Maître de conférences
Faculté d’Informatique
USTHB
souad.m.saighi@gmail.com
smarir@usthb.dz

}
 Objectifs

* Approfondir vos connaissances en termes de mécanismes

utilisés dans l’orienté objet
Pré-requis
● Connaissance des concepts de l’orienté objet

● Conception de solutions orientées objet et

mise en œuvre en java

● Maîtrise des éléments de base du langage

java
 Organisation

1h30 Cours 1h30 TP

 Evaluation
Evaluation en TP 40 % :

assiduité, participation, présence : 5 points

mini projet : 15 points

Examen final 60 %
 Plan du cours
01 Rappels sur l’Orienté Objet
02 Les exceptions
03 Générécité et Collections
04 Les interfaces graphiques
 Rappels
Classe
Pattern
constitué d’un
ensemble de code

Attributs Méthodes
Constantes et Fonctions et
variables procédures
définies dans la responsables du
classe traitement des
données
 Rappels
On peut Objet
instancier un
objet plusieurs Une représentation
fois de la classe

Etat Comportement
Valeurs des Methodes agissant
attributs sur l’état de
l’objet
 Exemple
Classe : Etudiant

Attributs : Nom, prenom, matricule

Méthodes : getName, getLastName, getMat, setName, setLastName, setMat

Objet : Etudiant
Instanciations : Etudiant1, Etudiant2
 Access modifiers
public private
Accessible par Accessible
absolument tout uniquement par
le monde la même classe

protected default
Accessible par le même Accessible
package et par les sous uniquement par
classes de la classe de le même package
définition
Paradigme orienté objet
Le paradigme orienté objet repose sur 4 piliers

Abstraire tout ce qui est complexe pour faciliter la

Abstraction communication entre objets

Garder l’état de l’objet privé et le manipuler

uniquement par ses méthodes
Encapsulation

Définir les relations hiérarchiques entre les classes

(permet la réutilisation d’éléments communs)
Héritage

créer des classes génériques et les spécialiser

(comme des sous-classes) tout en masquant les détails
Polymorphisme d’implémentation aux utilisateurs (Surcharge,
redéfinition)
 Mots clés static et final

static
Définit une variable
de classe ou une
méthode de classe
final
(exemple : main) Définit une
constante
exercice
Ecrivez une classe Etudiant avec les
attributs Nom, Prénom et matricule
Créer une classe main avec une méthode main
demandant à un utilisateur de créer un
étudiant en donnant une valeur à tous ses
attributs
02 { ..
Les Exceptions

} ..
 Plan du chapitre
01
Définition de la notion d’exception
02
Les différents types d’erreurs
03
Hiérarchie des classes d’exception
04
Gestion des exceptions (bloc try …catch)
05
Plusieurs exceptions dans un bloc try...catch
Définition de la notion d’Exception
Une exception est chargée de signaler un comportement
exceptionnel (mais prévu) d’une partie spécifique d’un
logiciel.
Dans les langages de programmation actuels, les
exceptions font partie du langage lui même. C’est le cas
de Java qui intègre les exceptions comme une classe
particulière: la classe Exception.
Cette classe contient un nombre important de classes
dérivées
C’est une façon plus propre de gérer tout ce que le
logiciel considère comme comportement inacceptable.
Définition de la notion d’Exception
Java dispose d’un mécanisme très souple nommé gestion
d’exception, qui permet à la fois :

• De dissocier la détection d’une anomalie de son

traitement
• De séparer la gestion des anomalies du reste du code,
donc de contribuer à la lisibilité des programmes
 Quelques Exceptions
{ • ArithmeticException : par exemple, division d’un
nombre par 0
• ClassCastException : par exemple, tentative de
transformer un objet String en Integer
• IndexOutOfBoundsException : par exemple, appeler un
index de tableau qui n’existe pas : tab[10] alors que
la variable tab n’a que 9 éléments.
• NullPointerException : appel d’une variable
non-existante ou d’un fichier non-existant par

•
exemple.
FileNotFoundException : exemple, tentative d’ouverture }
d’un fichier inexistant en lecture
Hiérarchie des Exceptions
Gestion
d’exceptions }
< Le bloc tr{} catch(){}…>
 Comment déclencher une
exception avec throw ?
{ Exemple :
Un point ne peut pas
avoir de coordonnées
négatives.

}
 Gestion d’une exception

{ Utiliser un bloc try et y inclure les instructions où on risque de

déclencher une exception :

try
{
// instructions
}
Faire suivre ce bloc par un gestionnaire d’exception par type d’exception
catch (TypeException e)
{
//Traitement en cas de déclenchement d’exception
}
}
 Exemple suite :

}
 Gestion d’une exception

{ Le code inclus dans un bloc try/catch

façons :
peut se terminer de trois

• Le code à l'intérieur du bloc try est exécuté avec succès et le

programme se poursuit.
• Le code à l'intérieur du bloc try rencontre une instruction return
et le programme sort de la méthode.
• Le code à l'intérieur du bloc try lève une exception et le contrôle
passe au bloc catch correspondant.

Soit celui-ci gère l'erreur et l'exécution de la méthode se poursuit ; soit

il réémet l'exception à destination de la méthode appelante.

Si un morceau de code doit être exécuté quoi qu'il arrive, il faut le

placer dans un bloc finally
}
 Mots clés

{ try, catch, finally,

throw, throws

}
 L’objet Exception
getMessage() : Cette méthode retourne le message associé
{
1.
à l'exception, souvent une description de l'erreur
survenue.
2. printStackTrace() : Cette méthode imprime la trace de la
pile d'exécution au moment où l'exception a été levée.
Cela aide à identifier où l'exception s'est produite
dans le code.
3. toString() : Cette méthode retourne une chaîne de
caractères représentant l'objet exception, généralement
contenant le nom de la classe et le message d'erreur.
https://docs.oracle.com/javase/8/docs/api/java/lang/Except }
ion.html
 printStackStrace()
Il vous est déjà probablement arrivé d’obtenir, lors de
{ l’exécution, un message d’erreur commençant par :
Exception in thread "main"
On obtient cela lorsqu’une exception survient sans être
traitée. Ce message présente la succession des différents
appels depuis main ayant conduit à la méthode coupable
Nous pouvons obtenir un message semblable en mentionnant
dans le bloc catch : e.printStackTrace() (ici e est le
paramètre de catch)

}
 Erreurs et Exceptions

{ Nous savons maintenant que la classe Exception hérite de

la classe Throwable.

Il existe une classe Error qui hérite aussi de Throwable

qui n’a pas de relation avec Exception (erreurs liées au
système, qu’on ne traite pas)

Ex : VirtualMachineError, LinkageError,
InstanciationError, InternalError
}
 Gestion de plusieurs exceptions
try {
{ }
// instructions

Faire suivre ce bloc par un gestionnaire d’exception par

type d’exception
catch (TypeException1 e){
//Traitement en cas de déclenchement d’exception de
type TypeException1 }
catch (TypeException2 e){
//Traitement en cas de déclenchement d’exception de
type TypeException2 } }
 Gestion de plusieurs exceptions

{ try
{
// instructions
}
Faire suivre ce bloc par un gestionnaire d’exception par
type d’exception
catch (TypeException1 | TypeException2 e)
{
//Traitement en cas de déclenchement d’exception de
type TypeException1 ou de type TypeException2 }
}
Dans la déclaration de la méthode

{ Access_modifier return_type method_name (parameters)

throws ExceptionType1, ExceptionType2, ExceptionType3
{
//instructions
}
Ex : public Point (int x, int y) throws
ErrCoordonnees , ErrDeplacement
{
//instruction }
}
exercice
On considére une autre méthode deplace (int
x, int y) qui déclenche une erreur si jamais
le déplacement du point est négatif.

Ecrivez cette méthode ainsi que la classe

ErrDeplacement ensuite, ajoutez au code
précédent un appel à cette méthode dans le
bloc try{} et modifiez le catch comme il se
doit
 Informations complémentaires

{ int f()
{ int n= 12;
try
{ float x;
……
}
catch(Exception e)
{ // on a pas accès à x mais on a accès à n
}
}
Questions
?
 03 { ..
Générécité et Collections

} ..
 Plan du chapitre généricité
01
La généricité en java
02
Mécanismes de généricité
03
Généricité et héritage
04
Généricité et classes abstraites
{ ..
La programmation générique
implique d'écrire du code qui
puisse être réutilisé pour des
objets de types quelconques

} ..
 Générique

Type quelconque,
Type fixé lors
Manipulation
de
d’objets de
l’instanciation
différents types

Par exemple Par exemple la même

trier des méthode est appelée
Double, int et pour trier des int
Float dans une puis est appelée une
même méthode autre fois pour trier
des Double… etc
 Premier concept : Exemple
public class Paire {

Object premier;
Object second;
public Paire(Object a, Object b){
premier = a;
second = b;
}
public Object getPremier(){return premier;}
public Object getSecond(){return second;}
. . . }
 Object

La classe Object est la classe dont

héritent implicitement toutes les classes
programmées en java. Ainsi, pour
structurer des données de type quelconque,
il suffit de déclarer des objets de type
Object
 Exemple

Paire p = new Paire ("abc", 35);

String x = (String) p.getPremier();
int y = (int) p.getSecond();

// Le casting est obligatoire

 Deuxième concept : Exemple
On définit une classe parametrée :
public class Paire <T> { // Ceci est une classe générique

T premier;
T second;
public Paire(T a, T b){
premier = a;
second = b;
}
public T getPremier(){return premier;}
public T getSecond(){return second;}
. . . }
 Classe générique
Quand on ne connaît pas à l’avance le type traité, on peut
spécifier un type indéfini dans la déclaration de la classe,
comme dans l’exemple :

public class Paire <T>

Le type T peut ensuite être utilisé au sein de la classe qui

est appelée classe générique

Particulièrement utile pour les classes de collection, comme

ArrayList (nous verrons cela dans la suite du chapitre partie
Collections)
 Classe générique
Ainsi, les attributs premier et second
pourront être de n’importe quel type.

Celui qui utilisera cette classe, spécifiera

le type qu’il désire utiliser.
 Classe générique
Le programme est alors plus simple et plus
sûr :
Paire <String> p = new Paire <String> ("abc",
"35");
String x = p.getPremier();
String y = p.getSecond();
System.out.println(y);
Par contre
int x = p.getPremier(); // erreur
 Classe générique
Exemple : Créer un type générique :
public class Value <T>{
private T v;
public Value (T v){ this .v = v; }
public T getValue() { return this .v; }
}// fin classeValue
Utilisation :
Value < Integer > v1 = new Value < Integer >(12);
int i = v1. getValue();
Value < String > v2 = new Value < String >(“Test”);
String ch= v2. getValue();
 Classe à plusieurs variables
de types différents
class Triplet <T, U, V> {
private T x; private U y; private V z;
public Triplet (T premier , U second , V troisième ) {
x = premier ; y = second ; z = troisième ;
}
public T getPremier() { return x; }
public U getSecond() { return y; }
public V getTroisieme() { return z; }
public void afficheTriplet() {. . . }
}
 Classe à plusieurs variables
de types différents
public class TestTriplet{
public static void main ( String args[]) {
int oi = 3; Double od = 5.25; String os= " hello ";
Triplet< Integer , Double , String > tips=
new Triplet < Integer , Double , String > (oi , od , os);
tips.afficheTriplet();
int n = tips.getPremier();
Double d = tips.getSecond();
String s = tips.getTroisieme();
System.out.println(" premier element du triplet = " + n+
"second element du triplet = " + d+
“troisieme element du triplet = " + s);
}// fin main
}// fin TestTriplet
 Méthode générique
On peut soit utiliser le caractère ?:
public static void method(? elem)
Ou faire précéder le type de retour de la méthode par le type
générique:

public static <T> T method(T elem)

On peut également obliger le type T à être une sous-classe
d’une classe déterminée ou à implémenter une interface
déterminée :

public static <T extends Paire > T method(T elem)

 Méthode générique
Exemple:
class TableauG{ . . .
// Méthode générique qui retourne la position milieu d’un
tableau
public static <T> T getMilieu(T[ ] tableau) {
return tableau[tableau.length/ 2];
}
. . .
} // fin classe TableauG
La méthode getMilieu est définie dans une classe ordinaire,
et non dans une classe générique.
 Méthode générique
Exemple:
String[] noms= {"Adel", "possède", "une", "petite",
"voiture" };
String milieu = TableauG.<String> getMilieu(noms) ;
Il n’est pas nécessaire de placer les types entourés des
signes <>, avant l'appel de la méthode.
Il fait correspondre le type des noms (donc, String[ ])
avec le type générique T[ ] et en déduit que T doit être un
String) On peut donc appeler de la manière suivante :
String milieu = TableauG.getMilieu(noms) ;
Généricité et héritage
 Règles d’héritage
Soit la classe paramétrée Paire:
public class Paire <T> { // classe générique
T premier ;
T second ;
public Paire (T a, T b){ premier a; second = b; }
public T getPremier(){ return premier ; }
public T getSecond(){ return second ; }
}
 Règles d’héritage
Soit la classe exécutable TableauG:
class TableauG{ …
public static Paire<T> getDeux(T[ ] tab,inti, intj){
return new Paire<T> (tab[i],tab[j]);
}
…
} // fin classe TableauG
 Règles d’héritage
Et soit la classe Personne:
class Personne{
private String nom, prenom;
public Personne(String nom, String prenom) {
this.nom=nom; this.prenom=prenom; }
public String getNom() { return nom; }
public String getPrénom() { return prenom; }
…
}
 Règles d’héritage
Et soit la sous-classe Elève :
class Eleve extends Personne {
private double[] notes = new double[10];
private int nombreNote= 0;
public Eleve(String nom, String prenom) {
super(nom, prenom); }
…
}
 Règles d’héritage
La question qui se pose:
"Est-ce que Paire <Elève> est une sous-classe de Paire
<Personne>" ?.

La réponse est «Non»

Par exemple, le code suivant ne sera pas compilé:

Eleve[] eleves = ... ;
Paire <Personne> personne = TableauG.getDeux(eleves,1,2);
 Règles d’héritage

En général, il n'existe pas de

relation entre Paire <S> et Paire <T>,
quels que soient les éléments auxquels S
et T sont reliés (même s’il y a de
l’héritage entre S et T)
Généricité et classes
abstraites
 Définition d’une classe
abstraite générique
Nous pouvons aussi définir une classe abstraite qui utilise
la généricité. Par exemple :
public abstract class AbstractClass<T> {
public abstract void method(T t);
}
public class ConcreteClass extends AbstractClass <String> {
public void method(String s) {
System.out.println(s);
}}
 Exercices Corrigés

https://docs.oracle.com/javase/tutorial/java/generics/Q
andE/generics-questions.html
{ Les collections
Les collections en java est un
ensemble d’interfaces et de
classes permettant de
manipuler les structures de
données usuelles
Vecteurs dynamiques,
listes chaînées,

} ..
files, piles, tables de
hachage….
 Plan du chapitre Collections
01 Hiérarchie des interfaces de collections
02
Description des interfaces
03 Implémentation des interfaces de collections
Set, List et Map
Hiérarchie des interfaces de
collection
Collection Map

Set List SortedMap

SortedSet
Hiérarchie globale
 Types de Collections
List : Tableau dynamique manipulé par
des indices, accepte les doublons

Set : N’accepte pas les doublons

Map : Chaque élément est représenté par

une clé et une valeur
 Collection List
.Pas de limite de taille
.Gérée par des indices
.Possibilité de stocker
n’importe quelle valeur List
(même NULL)

ArrayList LinkedList Vector

 Collection Set

Set

HashSet TreeSet LinkedHashSet

 Collection Map

Map

Hashtable HashMap TreeMap WeakHashMap

 Iterator
Iterator est une interface qui permet
de parcourir séquentiellement les
éléments d’une collection (List, Set,
Map) sans exposer la structure interne
de la collection
 Iterator
hasNext() retourne VRAI s’il reste des
éléments dans la collection
next() retourne le prochain élément de
l’itération
remove() supprime l’élément pointé par
l’iterator
 L’interface Collection
– boolean add(E element) : ajouter
– boolean contains(E element): vérifier
l’existence d’un élement
– boolean isEmpty() : vérifie si la collection
est vide
– Iterator<E> iterator() : position courante d’un
élément
– boolean remove(E element): supprimer un élément
– int size(): taille de la collection
– addAll, removeAll, toArray ….
 L’interface Collection

https://docs.oracle.com/javase/8/docs
/api/java/util/Collection.html
 L’interface Set

Set

HashSet TreeSet LinkedHashSet

 HashSet
.Utilise une table de hashage
 HashSet
.Utilise une table de hashage
 HashSet
. HashSet utilise une valeur de hachage
(difficile à prédire) calculée pour chaque
élément.
. Cette valeur de hachage détermine l'indice
de l’élément dans un tableau conteneur.
. Ainsi, l'ordre des éléments insérés n'est
naturellement pas conservé.
 L’interface HashSet

https://docs.oracle.com/javase/8/docs
/api/java/util/HashSet.html
 TreeSet
• Les éléments insérés sont automatiquement
triés
• Exige un seul type d’éléments
 TreeSet
• Les éléments insérés sont automatiquement
triés
• Exige un seul type d’éléments
 TreeSet
• Les éléments insérés sont automatiquement
triés
• Exige un seul type d’éléments
 L’interface TreeSet

https://docs.oracle.com/javase/8/docs
/api/java/util/TreeSet.html
 Collection List

List

ArrayList LinkedList Vector

ArrayList
 ArrayList
D’autres méthodes :
• add(int index, E element) insère element à la
position index dans la liste
• lastIndexOf(Object o) retourne l’index de la dernière
occurrence de l’élément spécifié ou -1 si l’élément
n’existe pas.
• remove(int index) supprime l’élément à la position
index et le retourne (E element).
• set(int index, E element) remplace la valeur de l’
élément d’indice index de la liste par element
exercice
Créez une méthode qui vérifie la dernière
position du nombre 99 dans un Arraylist
donné d’entiers, et ajoutez le nombre 100 à
l’index qui suit.

Créez une autre méthode qui supprime le

premier élément d’un ArrayList donné de
chaînes de caractères et modifiez le dernier
élément de ce ArrayList par la valeur
supprimée.
 L’interface ArrayList

https://docs.oracle.com/javase/8/docs
/api/java/util/ArrayList.html
 LinkedList
• Liste doublement chaînée
 LinkedList
D’autres méthodes :
• addFirst(E e) insère l’élément spécifié au début de
la liste
• addLast(E e) ajoute l’élément spécifié à la fin de la
liste (tout comme add ())
 L’interface LinkedList

https://docs.oracle.com/javase/8/docs
/api/java/util/LinkedList.html
 ArrayList vs LinkedList
. ArrayList est plus rapide pour l'opération de
recherche (get).
. LinkedList est plus rapide pour des opérations
d'insertion et de suppression.
. LinkedList utilise un chaînage double (deux
pointeurs) d'où une consommation de mémoire plus
élevée.
. Utilisez les ArrayList pour trier et accéder aux
données et utilisez les LinkedList pour manipuler les
données.
Opérations sur les listes
 Collection Map

Map

Hashtable HashMap TreeMap WeakHashMap

 HashTable
. Hashtable fonctionne avec un couple (clé, valeur)

. Elle utilise une table de hashage

. Elle n’accepte pas la valeur null

. La clé doit être unique

. Pour la parcourir, on utilise l’objet Enumeration

HashTable
D’autres méthodes de HashTable
. isEmpty () retourne true si l'objet est
vide, false sinon
. contains (Object value) retourne true si la
valeur existe dans la Hashtable, false sinon.
. containsKey (Object key) retourne true si la
clé existe dans la Hashtable, false sinon.
· elements () retourne une énumération des
éléments de l'objet
keys () retourne la liste des clés sous forme
d'énumération
Exemples
 L’interface Hashtable

https://docs.oracle.com/javase/8/docs
/api/java/util/Hashtable.html
 HashMap
. HashMap fonctionne aussi avec un couple (clé, valeur)

. Elle utilise aussi une table de hashage

. Elle accepte la valeur null

. La clé doit être unique

. Pour la parcourir, on utilise l’objet Entry

HashTable
 HashMap
Exemple de parcours clé/valeur avec la classe
Entry:
 L’interface HashMap

https://docs.oracle.com/javase/8/docs
/api/java/util/HashMap.html
 TreeMap
. TreeMap fonctionne aussi avec un couple (clé, valeur)

. Elle utilise aussi une structure d’arbre binaire de

recherche équilibrée pour stocker ses éléments

. Elle n’accepte pas la clé null

. La clé doit être unique

. Pour la parcourir, on utilise l’itérateur fourni par

entrySet()
 L’interface TreeMap

https://docs.oracle.com/en%2Fjava%2Fj
avase%2F11%2Fdocs%2Fapi%2F%2F/java.ba
se/java/util/TreeMap.html
 04 { ..
Les interfaces Graphiques

} ..
 Plan du chapitre
01 Généralités et Composants

02 Packages AWT et Swing

03 Création et affichage d'une fenêtre

04 Placer des composants dans une fenêtre

05 Gestion des événements

 Généralités
Les interfaces graphiques sont des
environnements visuels qui permettent
aux utilisateurs d'interagir avec les
logiciels et les systèmes informatiques
en utilisant des éléments graphiques
tels que des fenêtres, des boutons, des
menus, des icônes, etc., plutôt que des
commandes textuelles.
 Composants
Les principaux objets qui composent une
interface graphique sont :
1. Une fenêtre
2. Un panneau
3. Des contrôles graphiques (boutons, champs
textuels…etc)
4. Des gestionnaires de disposition (layout
managers)
 Packages AWT et Swing

AWT (Abstract Window Toolkit) est la

première bibliothèque graphique incluse dans
Java.

•AWT est basé sur les composants natifs de la

plateforme sous-jacente et fournit un
ensemble de composants graphiques.
 Packages AWT et Swing
•Les composants lourds sont ceux qui sont
basés sur les composants natifs de la
plateforme et offrent une intégration
native, mais ils peuvent avoir des problèmes
de portabilité.

•AWT manque de fonctionnalités avancées

telles que les composants de
glisser-déposer, les fenêtres internes, et
est limité en termes de personnalisation et
d'apparence.
 Packages AWT et Swing

•Swing est une bibliothèque graphique plus

récente qui a été ajoutée à Java pour
surmonter les limitations d'AWT.

•Il est entièrement écrit en Java et

n'utilise pas les composants natifs de la
plateforme, ce qui le rend plus portable.
 Packages AWT et Swing
•Swing fournit un ensemble complet de
composants graphiques, y compris des
composants avancés tels que des fenêtres
internes, des onglets, des arbres, des
tables, etc.

•Les composants Swing sont légers, ce qui

signifie qu'ils sont indépendants de la
plateforme et offrent une apparence
cohérente sur différentes plateformes.
 Packages AWT et Swing

•Swing est hautement personnalisable et

extensible, permettant aux développeurs de
créer des interfaces utilisateur complexes et
esthétiquement plaisantes.

•Il prend en charge des fonctionnalités

avancées telles que le glisser-déposer.
Création et Affichage d’une
fenêtre