PARADIGME ORIENTÉ-OBJET

A programming
paradigm that uses
objects to design
systems.

Sébastien Adam Une introduction des concepts de base

 Principes fondamentaux
2

Modularité : vise à répartir les opérations d'une application sur

plusieurs modules, afin que le cycle de vie de chaque module soit
indépendant des autres.

Abstraction : vise à représenter un élément conceptuel et

rendre certains détails de l’élément logiciel correspondant
invisibles afin de faciliter la conception d’applications.

Encapsulation : vise à regrouper les données et les opérations

pouvant y accéder. L’interface (l’ensemble des opérations)
contrôle les accès aux données.

Cohésion / Couplage : vise à guider la façon de réaliser la

modularité, l’abstraction et l’encapsulation afin d’améliorer les
caractéristiques (réutilisabilité, etc.) d’un module.
 Constitution d’un programme Java
3

Un programme Java utilise un ensemble de classes

Les classes sont regroupées dans un ou plusieurs packages

Une classe regroupe un ensemble d’attributs et de méthodes

Package

Classe
Attributs

Méthodes
 Classe
4

Une classe existe au moment de la compilation.

Une classe est un type dans un langage OO.

Une classe définit une implémentation.

 Implémentation = méthodes + attributs + états possibles

Plusieurs catégories de méthodes constituent une classe :

constructeurs, accesseurs, mutateurs et destructeur.
 Classe Hello
5

package mesExemples;
class Hello {
public static void main (String argv[])
{
Hello hello = new Hello(); // Instantiation
hello.SayHello();
}
public void SayHello()
{
System.out.println("Hello Java World !!! ");

}
 Objet
6

Une variable d’un type classe est une référence vers un objet.

Un objet existe au moment de l’exécution.

Un objet est créé (instancié) lorsque le constructeur d’une

classe est exécuté.

Un objet a une identité et un type fixes.

Un objet a un état variable.

 Classe et objets
7

Les deux instances (objets) sont définies par une taille, un

nombre et des types d’attributs et un ensemble de méthodes
identiques.

Par contre, les objets n’ont pas le même état.

Voiture Bmw :Voiture

couleur : Couleur=Color.Black Instance de couleur=rouge
vitesseMax : float = 150 vitesseMax=230
demarrer()
arreter() Twingo : Voiture
accelerer(acc : float) Instance de
couleur=jaune
Freiner(acc : float)
vitesseMax=140
 Attribut
8

Un attribut est déclaré par sa visibilité, son type et son nom.

Un attribut n’est pas accessible publiquement par défaut mais

ils existent des modificateurs d’accès : public, private,
protected.

Lors de la création d’un objet, les attributs sont initialisés par

défaut (0, 0.0, null, false).

Les attributs peuvent être initialisés lors de la définition ou

dans le constructeur.

La valeur d’un attribut déclaré comme « static » est partagée

par toutes les instances (objets) de la classe.
 Méthode
9

Une méthode est déclarée par sa signature.

 Signature = nom + paramètres (type et ordre).

 Une signature est unique dans une classe.

Le principe de surcharge permet à deux méthodes d’avoir le

même nom à l’intérieur d’une classe.

Une méthode est accessible publiquement par défaut mais ils

existent des modificateurs d’accès : public, private, protected.
 Surcharge (1/3)
10

 Une méthode surchargée a le même nom que d’autres méthodes

de la même classe

 Exemple
void print () {…}
void print (int i) {…}
int print (float f) {…}

 Le type du paramètre de retour n’est pas pris en compte par le

mécanisme de résolution de surcharge
 Surcharge (2/3)
11

 A l’appel, Java détermine quelle est la méthode dont la liste des

paramètres formels correspond le mieux aux paramètres
effectivement donnés par l’appelant

 Si aucune signature de méthode ne correspond au valeurs

envoyées, la machine virtuelle Java est capable de convertir une
valeur envoyée dans le type du paramètre formel

 Java détermine le coût des conversions possibles et choisit le coût

le moins élevé. Si le coût global de conversion dépasse 10, Java
refuse l’appel
 Surcharge (3/3)
12

vers Coût des conversions

byte short char int long float double
de
byte 0 1 2 3 4 6 7

Short 10 0 10 1 2 4 5

Char 11 10 0 1 2 4 5

Int 12 11 11 0 1 5 4

Long 12 11 11 10 0 6 5

Float 15 14 13 12 11 0 1

double 16 15 14 13 12 10 0
 Constructeur
13

Il porte le même nom que la classe.

Appeler le constructeur (new) permet de créer une instance

(objet) et initialiser ses attributs.

 Réserve l’espace mémoire pour un objet (requête au GC) ;

 Initialise les variables ;

 Retourne une référence à l’objet de la classe (mais le type de retour est void).

Si aucun constructeur n’est écrit, celui par défaut ne fait rien

et les attributs sont initialisés avec leur valeur par défaut.

 S’il y a un constructeur écrit, celui par défaut n’existe plus et il faut donc l’écrire
explicitement au besoin.
 Exemple de constructeurs
14
class Date {
int _jour;
int _mois;
int _an;

Date() {
_an = 1999;
}

Date (int jour, int mois, int an) {

_jour = jour;
_mois = mois;
_an = an;
} ...
Date d = new Date(10,12,2000); // instantiation de l’objet
 Création d’objets
15

class Voiture { // Définition de la classe

String _type;
Voiture (String type) {
_type = type;
}
void demarrer () {
System.out.print( this._type );
}
}
...
Voiture maVoiture = new Voiture("Aveo"); // Création de l’objet
Voiture uneVoiture = maVoiture; // Deuxième référence sur l’objet
uneVoiture.demarrer();
 L’accesseur « this »
16

C’est une référence gérée par Java.

C’est un paramètre implicite pour toute méthode non static.

C’est une référence à l’objet sur lequel la méthode a été

appelée.
 « this »
17

 « this » = référence sur l’objet courant

class Compte {
void crediter(float montant) {……};
void debit(float montant) {……};
}

class Versement {
void valider() {……}
void effectuer(Compte s, Compte d, float montant) {
s.debiter(montant);
d.crediter(montant);
this.valider();
}
}
 « this »
18

Soit :

public class UneClasse

int x;
objet 1 objet2
public void methode1(){
this.x = 5;
... x 5 X
5
}

UneClasse objet1 = new UneClasse();

UneClasse objet2 = new UneClasse();

objet1.methode1(); //this == objet1 dans methode1()

objet2.methode1(); //this == objet2 dans methode1()
 « this » dans le constructeur
19

class Personne {
String _nom ;
String _prenom;
float _taille;

Personne(String nom, String prenom) {

_nom = nom;
_prenom = prenom;
}

Personne(String nom, String prenom, float taille) {

this(nom, prenom);
_taille = taille;
}
 Le Garbage Collector (GC)
20

Il prend en charge la gestion de la mémoire

Il alloue l’espace mémoire lors de la création des objets

Il libère la mémoire occupé par un objet dès que celui-ci n’est

plus référencé par l’application

Il est capable de compacter la mémoire pour éviter la

fragmentation

System.gc(); permet d’appeler le Garbage Collector en Java.

 « null »
21

 La valeur « null » peut être assignée à n’importe quelle référence

sur un objet
 Une méthode peut retourner « null »
 L’appel d’une méthode sur une référence d’objet valant « null »
provoque une erreur d’exécution (NullPointerException)
 On peut tester une référence pour savoir si elle vaut « null »

Personne moi = new Personne();

……
if (moi != null) {
System.out.println("J’existe toujours ! ");
}
 Objet non référencé
22
c1
Cercle c1, c2; // null par défaut null
1 c2
x: 2.0
c1 y: 3.0
c1 = new Cercle(2.0, 3.0, 4.0); r: 4.0
2
c2
null
c2 = c1;
x: 2.0 4
c1 y: 3.0 x: 2.0
c2.r = c2.r – 1; 3 r: 4.0 c1 y: 3.0
c2 r: 3.0
null c2
c1 = new Cercle(2.0); null
x: 2.0
c1 y: 3.0
c1.x = 2.0; 5 r: 3.0 6
c2 x: 2.0
x: 0.0 c1 y: 3.0
x: 2.0 y: 0.0 r: 3.0
c2 = c1; c1 y: 3.0 r: 2.0
c1 c2
7 r: 3.0
x: 2.0
c2 8 y: 0.0
System.gc(); x: 2.0 c2 r: 2.0
y: 0.0 x: 2.0
r: 2.0 y: 0.0
r: 2.0
 Accesseur
23

Une méthode accesseur permet d’obtenir le contenu des

attributs d’une classe.

Il commence souvent par « get ».

Il n’a habituellement pas de paramètres.

Il sert à retourner le contenu d’un attribut privé.

Si une classe n’a que des accesseurs, on dit qu’elle est immuable.
 Mutateur
24

Une méthode accesseur permet de modifier le contenu des

attributs d’une classe.

Il commence souvent par « set ».

Il a habituellement au moins un paramètre.

Il ne retourne habituellement rien.

Si une classe a des mutateur, on dit qu’elle est mutable.

 Destructeur
25

Il est implémenté par la méthode Finalize().

Cette méthode permet, lorsqu’un objet n’est plus accessible, de

remettre au système les ressources utilisées par cet objet.

Cette méthode est appelée automatiquement lorsque la dernière

référence à une instance n’y fait plus référence.

Nous n’en utiliserons pas dans ce cours.

 La méthode « finalize »
26

import java.util.*;
class Point { ……
protected void finalize()
{System.out.println("Appel au Destructeur"); }
};
public class Exemple {
public static void main (String []arg) {
Point a ;
Scanner clavier = new Scanner(System.in);
System.out.println("Création de a");
a= new Point(1,2); // Création du point 1,2, constructeur 1
System.out.println("Fin creation de a");
a=null;
clavier.nextLine();
System.gc(); // Destruction du point a
System.out.println("Creation de b");
Point b = new Point(); // Création du point 0,0 constructeur 2
}
 Opérateurs sur les références
27

 Egalité de deux références : ==

Compare si 2 références pointent vers le même objet

 Différence de deux références : !=

Compare si 2 références pointent vers des objets différents

 Type d’instance de la référence : instanceof

Permet de savoir si l’objet référencé est une instance d’une classe donnée ou
d’une de ses sous-classes

Personne moi = new Personne();

……
if (moi instanceof Personne) {
System.out.println("Je suis bien une personne! ");
}
 Le modificateur « static »
28

La valeur d’un membre public définie comme étant static existe

pour tous les objets d’une même classe.

Un attribut static n’est pas initialisé lors de l’instanciation d’un

objet mais une seule fois au début d’un programme.

S’il y a une modification sur un attribut static, tous les objets

de la classe en verront les effets.

Une méthode static ne peut utiliser que des membres static.

On utilise le nom de la classe pour accéder a un membre static.

 Exemple de méthode « static »
29

class MathUtil {
final static double _PI = 3.14 ;
static double PI() {
return _PI;
}
static double Carre(double x) {
return x * x;
}
static double Demi(double x) {
return x / 2;
}
}
……
double i = MathUtil.Carre(5);
double x = MathUtil.PI();
 Les packages : définition (1/2)
30

 Un package est une bibliothèque de classes

 On regroupe les classes d’un même domaine dans un package

 Les packages sont organisés hiérarchiquement

 La notion de package apporte un niveau d’encapsulation

supplémentaire
 Les packages : définition (2/2)
31

 Les classes du JDK sont classées dans des packages

java

lang util awt net

String.class Date.class event Button.class Socket.class

Thread.class Vector.class List.class URL.class
…

 Java importe automatiquement le package « java.lang » qui

contient des classes comme « Thread » ou « System »
 Les packages : utilisation (1/2)
32

 Il y a 2 manières d’utiliser une classe stockée dans un package :

Utilisation du nom complet

java.util.Date dateDuJour = new java.util.Date();

System.out.println(dateDujour);

Importer une classe ou toutes les classes du package

import java.util.Date;
Date dateDuJour = new Date();
System.out.println(dateDujour);

import java.util.*;
Date dateDuJour = new Date();
System.out.println(dateDujour);
 Les packages : utilisation (2/2)
33

 Le mot-clé « package » permet de définir un nouveau package

 La hiérarchie des packages correspond à la hiérarchie des
répertoires
//fichier Compte.java dans le répertoire Finance
package finance;
public class Compte {
…… }

//Fichier Client.java dans le répertoire de l’application

import finance.*;
public class Client {
Compte c = new Compte();
…… }
 Les paquetages de Java
34
 La variable CLASSPATH
35

 Le compilateur utilise la variable d’environnement CLASSPATH

pour localiser les classes d’un package sur le disque

 Cette variable doit référencer tous les répertoires ou fichiers dans

lesquels sont susceptibles de se trouver des classes Java

 On a le droit de placer les classes dans des archives (zip, jar, cab)

Dans ce cas, la variable CLASSPATH doit référencer le fichier

 La hiérarchie des classes des packages doit être respectée

 Privilèges d’accès (visibilité)
36

Soit un membre m déclaré dans une class A

accès au membre m à partir de

classe A classe B
B et A même package B et A package différent
B n'est pas B n'est pas
B sous- sous-classe B sous- sous-classe
visibilité classe de A de A classe de A de A
private O N N N N
protected O O N O N
public O O O O O
package O O O N N
 Règles de visibilité
37

 L’encapsulation consiste à déclarer les attributs « private ».

 On déclare alors des méthodes «public » (accesseurs/mutateurs)

permettant de lire et/ou de modifier les attributs

Si un accesseur retourne une référence sur un objet, rien n’empêche la

modification de cet objet à travers cette référence  cela brise l’encapsulation

class Personne {
private Vector children = new Vector();
public Vector getChildren() { return children; } }
……
Personne moi = new Personnes();
Vector v = moi.getChildren(); Rupture de
l’encapsulation
v.addElement(new Personne("Paul");
 La classe « Object »
38

 Classe mère de toutes les classes

Permet d’utiliser les classes conteneurs et le polymorphisme
 La méthode « toString() » retourne une description de l’objet
 La méthode « equals(Object) » teste l’égalité sémantique de deux
objets
 Le méthode « getClass() » retourne le descripteur de classe. Il
permet de :

connaître la classe d’un objet

connaître le nom de la classe, ses ancêtres

découvrir la structure des objets (JDK 1.1)
 Les classes « Wrapper »
39

 Les types de base Java ne sont pas des objets

Il est parfois indispensable de les manipuler comme des objets
 Les classes Wrapper représentent un type de base

Récupérer les valeurs min et max

Créer une instance à partir d’un type de base ou d’une chaîne

Conversions entre types de base et chaînes

Conversions entre chaînes et types de base

Utiliser des types de base dans des conteneurs
 Boolean, Integer, Float, Double, Long, Character
 Attention : ne supporte pas d’opérateurs (+, -, …)
 Elles sont dans le package java.lang
 « Wrapper » vs « types de base »
40

 Avantages des type de bases :

Plus léger en mémoire

Supporte un certain nombre d’opérateurs

Autorise certaines conversions automatiques de types

 Avantages des Wrappers :

Est passé par référence

Dispose de méthodes de conversions statiques vers les autres types

Peut être géré par les objets container
 Exemples
41

 Convertir une chaîne en entier :

static int convertir(String s) {
try {
return Integer.parseInt(s);
} catch(Exception e) { return 0; }
}

 Convertir un entier en chaîne :

static String convertir(int i) {
Interger j = new Integer(i);
return j.toString();
}
 La classe java.lang.String
42

 Contient une chaîne de caractères

 Classe connue par le compilateur Java

Une chaîne constante sera convertie en objet de la classe String

String msg = “Hello Java World !”
 Un objet de la classe String ne peut pas être modifié

Ne brise pas l’encapsulation

class Personne {
String nom;

public String getNom() {

return nom;
}
}
 String : concaténation
43

int area = 33;

int prefixe = 1;
int suffixe = 02030405;
// Chaque concaténation crée un nouvel objet
// l’ancien est détruit par le Garbage Collector
String numTel = "(" + area + ")"; // (33)
numTel += prefixe // (33)1
numTel += "-" // (33)1-
numTel += suffixe // (33)1-02030405

// Un seul objet est créé

numtel = "(" + area + ")" + prefixe + "-" + suffixe

// Conversion d’un entier en chaîne

String un = 1 + "";
 String : manipulation
44

 length() : cette méthode permet de connaître le nombre de

caractères d’une chaîne

Ex : for (int i = 0; i < monTexte.length(); i++) {......}
 indexOf(char c, int i) : retourne la position du caractère “c” à partir
de la position “i”

if (monTexte.indexof(‘$’, 5) <> -1 ) {......}
 substring(int i, int j) : extrait de la chaîne les caractères de la
position “i” à la position “j”

String nouveauMot = ancienMot.substring(2,5);
 equals() : retourne un booléan signifiant si les deux chaînes sont
identiques

Ex : if ( mot1.equals(mot2)) {......}
 La classe java.lang.StringBuffer
45

 C’est une chaîne de caractères modifiable et de taille variable

 Son utilisation est moins simple que « String »

pas d’utilisation possible de l’opérateur +
 append(p) : ajoute “p” en fin de la chaîne courante

“p” peut être de n’importe quel type de base
 length() : retourne la longueur de la chaîne
 setLength() : change la longueur de la chaîne

Si elle est étendue, les nouveaux caractères sont initialisés à 0