Programmation Orientée Objet : Java

Bibliographie

2
 Plan
 Introduction à la POO
 Introduction au langage JAVA
 Bases du langage
 Classes et objets
 Héritage
 Héritage et polymorphisme
 Les indispensables : package, collections et exception
 Les interfaces graphiques (GUI)

3
 Introduction à la POO

4
 Introduction
Critères de qualité d’un logiciel:
 La correction : Un logiciel doit exécuter exactement les tâches
définies par sa spécification et fournir exactement les résultats
demandés.
 Robustesse : le logiciel est capable de bien fonctionner dans des
conditions anormales.
 L’extensibilité : Les programmes doivent s’adapter facilement aux
changements de spécification afin d’intégrer facilement de nouvelles
fonctionnalités
 L’efficience : Temps d’exécution, taille mémoire, etc.
 La portabilité : C’est la facilité avec laquelle on peut exploiter un
même logiciel dans différentes implémentations.
 La réutilisabilité : C’est la possibilité d’utiliser certaines parties du
logiciel pour résoudre un autre problème.

5
 Programmation Procédurale (PP)
 Principe: Repose sur l’équation suivante :
Programme = Structures de données + Algorithmes
 Dans la PP, la conception d’un programme est conduite par
traitements :
Consiste à décomposer le programme en fonctions (modules)
simples. main()
Données

init() calcule()
Données
trie()
factorise()
6
compare() permute()
 Programmation Orientée Objet (POO)
 Basée sur les données :
 Déterminer les données à traiter.
 Réaliser les fonctions qui permettent de les manipuler.

Données Données

init() calcule() trie()

factorise() compare() permute()

7
 Programmation Procédurale VS POO
 Objectifs de la POO
 Facilité la réutilisation de code, encapsulation et abstraction
 Facilité de l’évolution du code
 Améliorer la conception et la maintenance des grands systèmes
 Programmation par « composants ». Conception d’un logiciel à la
manière de la fabrication d’une voiture.
 Programmation Procédurale
 Unité logique : le module
 Une zone pour les variables
 Une zone pour les fonctions
 Chaque fonction résout une partie du problème
 Structuration « descendante » du programme

8
 Programmation Orientée Objet (POO)

OBJET = Données + Méthodes.

 Un objet est une association de données et de fonctions
(méthodes) qui agissent sur ces données.

 POO: Programmation dans laquelle un programme est

organisé comme un ensemble d'objets coopérant ensemble.

9
 Les Concepts de base de la POO
 Un Objet a :
 Ses propres données (attributs) qui peuvent être des données
simple (entier, texte, …) ou d’autres objets.
 Ses propres méthodes (fonctions membres) qui représente son
comportement.
Ce sont les traitements qu'on peut appliquer aux données.
 Une identité qui permet de l'identifier parmi les autres objets.
 Exemple :
Marque : Renault
Modèle : Megane
Couleur : Noir
Etat : En Marche
Moteur : Diesel; 85 Cheveaux

Démarrer() Arrêter() Peindre(NouvColor) GetEtat () …

10
 Les Concepts de base de la POO…
 Un objet possède également une durée de vie :
la durée de temps entre sa création et sa destruction.
 On conçoit un objet comme une représentation abstraite
d’un composant du système vu par l’utilisateur.

Formule à retenir :
Objet= Etat (Attributs) + Comportement (Méthodes)+ Identité

11
 Les Concepts de base de la POO…
 Les objets communiquent entre eux par des envoies de
messages.
 Un objet peut recevoir un message qui déclenche
 une méthode qui modifie son état
et/ou
 une méthode qui envoie un message à un autre objet

demarre()
maVoiture leMoteur

12
 Les Concepts de base de la POO…
 Les objets qui ont les mêmes états et les mêmes
comportements sont regroupés : classe
 Les classes servent de « moules » pour la création des objets.
 Un objet est une instance (exemplaire) d’une classe.
 Un programme OO est constitué de classes qui permettent
de créer des objets qui s’envoient des messages.

13
 Les Concepts de base de la POO…
 Classe :
 généralisation de la notion de type.
 décrit les caractéristiques générales d’un ensemble (famille)
d’objets similaires :
Les objets similaires sont des instances (exemplaires) de la même classe.
 possède des membres :
 Attributs : les éléments données de la classe
 Méthodes : fonctions qui donne accès ou modifie les attributs.

 Exemple :

Classe Livre Germinal

-titre, auteur E. Zola Le seigneur des anneaux
[Link]

14
 Les Concepts de base de la POO…
 Masquage de l’information :
 Consiste à limiter l'accès aux données d’une classe.
 Normalement, les valeurs des attributs d’un objet ne sont pas
accessibles directement par un autre objet.
On dit que les attributs sont masqués à l’intérieur d’un objet.
Les attributs masqués sont dits privés.
Ceux qui ne sont pas masqués sont appelés attributs publiques.
L'accès aux attributs privés est effectué via des méthodes.

15
 Les Concepts de base de la POO…
 Encapsulation des données :
 L'encapsulation est un mécanisme consistant à rassembler les
données et les méthodes au sein d'une même classe en cachant
l'implémentation de l'objet, c'est-à-dire en empêchant l'accès
aux données par un autre moyen que les méthodes proposés.

Données

Méthodes

16
 Les Concepts de base de la POO…
 Accès aux attributs d'un objet :
Syntaxe : [Link]
Exemple : P est un objet de la classe Etudiant qui un attribut
Matricule de type entier

[Link] = 234;

 Accès aux méthodes d'un objet :

Syntaxe : NomObjet.Méthode(arguments)
Exemple : C est un objet de la classe Compte qui a une méthode Verser qui
verse un montant dans le compte :

[Link] (4000); // verser 4000 dans le compte C

17
 Les Concepts de base de la POO…
 Stratégie de développement OO :
1. Identifier les objets et leurs attributs
Exemple : CompteBancaire
1. Identifier les opérations (Exemple: Verser, Retirer, …).
2. Établir la visibilité. Par exemple, pour un objet
CompteBancaire on pourra avoir accès à toutes les actions
(Verser, Retirer, …) mais ne pourra pas voir l'accès
directement au solde pour le modifier.
3. Établir l’interface : description de chaque opération avec ses
arguments (Exemple : boolean Verser( float M) )
4. Implanter chaque objet.

18
 Présentation du langage
 Sun définit le langage Java comme:
 Objet :
 Inspiré du C++, Objective C et Smalltalk , Java est un langage fortement objet.
 Simple :
 Il est toutefois allégé de toutes les sources d’erreurs du C++ (pointeurs, gestion
mémoire, etc.) et des fonctionnalités "tordues" et peu utilisées.
 Distribué :
 Java contient un ensemble de classes permettant d'utiliser des protocoles TCP/IP tels
que HTTP et FTP. L'utilisation des URL se fait aussi "simplement" que l'ouverture de
fichiers locaux.
 Robuste :
 Le maximum de vérifications sont faites à la compilation (protection des classes,…).
 Pas de gestion explicite de la mémoire (GC en thread), pas de pointeur, ..
 Sécurisé :
 Java est très sécurisé (SecurityManager).

19
 Présentation du langage...
 Interprété :
 Avantage au développement.
 Mais est pour l'instant un inconvénient à l'exécution (performances).
 Indépendant de l'architecture :
 C'est la machine virtuelle qui assure cette indépendance.
 Portable :
 Contrairement au C/C++ Java n'est pas dépendant de l'implémentation, les
types de base ont des tailles fixes.
 Multithread :
 C'est la possibilité d'exécuter plusieurs tâches simultanément.
 Dynamique :
 Java a été conçu pour fonctionner dans un environnement évolutif.
 Compact :
 L'interpréteur Java n'a besoin que de 215Ko.
 Chargement dynamique des classes.

20
 Le Langage JAVA
 Informations Générales
 Conçu par Sun Microsystems (Write Once Run Anywhere)
 Langage orienté objet, inspiré de C++
 De nombreuses fonctionnalités Réseau et Internet
 Langage fortement typé
 Gestion du multitâche
 Gestion mémoire réalisée par un Garbage Collector
 Langage compilé vers du pseudo code binaire nommé
"ByteCode", interprété au sein d'une machine virtuelle (VM)
Portabilité = disponibilité de la machine virtuelle Java
Java Source Exécution

ByteCode
21 Compilation Machine Virtuelle
 Bases du langage

22
 Premier exemple de programme en
Java
public class PremierProg {
public static void main(String[] argv) {
[Link]("Bienvenue, mon Premier Programme Java");
}
}

 public class PremierProg : Nom de la classe

 public static void main : La fonction principale équivalent à la fonction
main du C/C++.
 String[] argv : Permet de récupérer des arguments transmis au programme au
moment de son lancement
 [Link]("Bienvenue, ...") : Méthode d'affichage dans
la fenêtre console.
23
 Mise en œuvre
 Pas de séparation entre définition et codage des opérations
 Un seul fichier "[Link]".
 Nom de la classe = Nom du fichier java
 Pas de fichier d’en tête comme C/C++.
 Compilation
javac [Link] ou javac *.java quand plusieurs classes
 Génération d’un fichier Byte-Code "[Link]"
 Pas d’édition de liens (seulement une vérification)
 Exécution
java NomDeClasse
 Choisir la classe principale à exécuter

24
 Types primitifs de Java
 Ne sont pas des objets !!!
 Occupent une place fixe en mémoire réservée à la déclaration
 Types primitifs :
 Entiers : byte (1 octet), short (2 octets), int (4 octets) et long
(8 octets).
 Flottants : float (4 octets) et double (8 octets)
 Booléens : boolean (true ou false)
 Caractères : char (codage Unicode sur 16 bits)
 Chacun des types simples possède un alter-ego objet disposant de
méthodes de conversion (à voir dans la partie Classes et Objets).
 L’autoboxing introduit depuis la version 5.0 convertit de manière
transparente les types primitifs en références.

25
 Initialisation et constantes
 Initialisation
 Une variable peut recevoir une valeur au moment de sa déclaration :
int n = 15; Penser à l’initialisation au risque
boolean b = true; d’une erreur de compilation
int n;
 Cette instruction joue le même rôle : [Link](" n = " + n);
int n;
n = 15;
boolean b;
b = true;
 Constantes
 Ce sont des variables dont la valeur ne peut affectée qu'une fois
 Elles ne peuvent plus être modifiées
 Elles sont définies avec le mot clé final
final int n = 5;
final int t;
...
t = 8;
n = 10; // erreur : n est déclaré final
26
 Structure de contrôle
 Choix :
 Si alors sinon : if condition {...} else {...}
 Itérations :
 Boucle :
for (initialisation; condition; modification){ ...}
 Boucle (for each) :
for (Type var : Collection) {...}
 Tant que :
while(condition) {...}
 Faire jusqu’à :
do {...} while (condition)
 Sélection bornée
 Selon faire :
switch ident { case valeur0 : ... case valeur1 : ... default:
...}
 Le mot clé break demande à sortir du bloc

27
 Structure de contrôle
 Exemple : structure de contrôle
public class SwitchBreak {
public static void main(String[] argv) {
int n = ...;
[Link]("Valeur de n :" + n);
switch (n) {
case 0:
[Link]("nul");
break;
case 1:
case 2:
[Link]("petit");
case 3:
case 4:
case 5:
[Link]("moyen");
break;
default:
[Link]("grand");
}
[Link]("Adios...");
}
28 }
 Opérateurs sur les types primitifs
 Opérateurs arithmétiques
 Unaires : +a, -b
 Binaires : a+b, a-b, a*b, a%b
 Incrémentation et décrémentation : a++, b--
 Affectation élargie : +=, -=, *=, /=
 Opérateurs comparaisons
 a==b, a!=b, a>b, a<b, a>=b, a<=b

 Opérateurs logiques
 Et : a && b, a & b
 Ou : a || b, a | b
 Conversion de type explicite (cast)
 (NouveauType)variable

29
 Opérateurs sur les types primitifs
 Exemple :
public class ExempleTypesPrimitifs {
public static void main(String[] argv) {
int compteur = 0;
while (compteur != 100) {
// Prend un nombre aléatoire
double nbreAleatoir = [Link]() * 1000;
// Etablie un index de 0 à 10
int index = compteur % 10;
// Construction de l’affichage
[Link]("Index : " + index + " Nbre Aléatoir : "
+ (int) nbreAleatoir);
// Incrémentation de la boucle
compteur += 1;
}
}
}

30
 Affectation, recopie et comparaison
 Affecter et recopier un type primitif
 a=b : signifie a prend la valeur de b
 a et b sont distincts
 Toute modification de a n’entraîne pas celle de b
 Comparer un type primitif
 a == b : retourne true si les valeurs de a et b sont identiques

31
 Les tableaux en Java
 Les tableaux sont considérés comme des objets
 Fournissent des collections ordonnées d’éléments
 Les éléments d’un tableau peuvent être
 Des variables d’un type primitif (int, boolean, double,
char, …)
 Des références sur des objets (à voir dans la partie Classes et
Objets)
 Création d’un tableau
1. Déclaration : déterminer le type du tableau
2. Dimensionnement : déterminer la taille du tableau
3. Initialisation : initialiser chaque case du tableau

32
 Les tableaux en Java : Déclaration
1. Déclaration
 La déclaration précise simplement le type des éléments du
tableau
int[] monTableau;
 Peut s’écrire également
int monTableau[];

Une déclaration de tableau ne doit pas préciser de dimensions

int monTableau[5]; // Erreur

33
 Les tableaux en Java : Dimensionnement
2. Dimensionnement
 Le nombre d’éléments du tableau sera déterminé quand l’objet
tableau sera effectivement créé en utilisant le mot clé new
 La taille déterminée à la création du tableau est fixe, elle ne
pourra plus être modifiée par la suite
 Longueur d’un tableau : [Link]
int[] monTableau; // Déclaration
monTableau = new int[3]; // Dimensionnement

 La création d’un tableau par new

 Alloue la mémoire en fonction du type de tableau et de la taille
 Initialise le contenu du tableau à 0 pour les types simples

34
 Les tableaux en Java : Initialisation
3. Initialisation
 Comme en C/C++ les indices commencent à zéro
 L’accès à un élément d’un tableau s’effectue suivant cette forme:
monTab[varInt]; // varInt >= 0 et <[Link]

 Java vérifie automatiquement l’indice lors de l’accès (exception levée)

 Autre méthode : en donnant explicitement la liste de ses éléments entre

{…}
int[] monTab = {1, 2, 3}
 est équivalent à :
monTab = new int[3];
monTab[0] = 1; monTab[1] = 2; monTab[2] = 3;
35
 Les tableaux en Java : Synthèse
1. Déclaration  Ou 1, 2 et 3
int[] monTableau; int[] monTab = {1, 2, 3};

1. Dimensionnement
monTableau = new int[3];

2. Initialisation
monTableau[0] = 1;
monTableau[1] = 2;
monTableau[2] = 3;
for (int i = 0; i < [Link]; i++) {
[Link](monTableau[i]);
}

for (int current : monTableau) {

[Link](curent);
36 }
 Les tableaux en Java : Multidimensionnels
Tableaux dont les éléments sont eux mêmes des tableaux
 Déclaration
type[][] monTableau;
 Tableaux rectangulaires
 Dimensionnement :
monTableau = new type[2][3];
 Tableaux non-rectangulaires
 Dimensionnement :
monTableau = new type[2];
monTableau[0] = new type[2];
monTableau[1] = new type[3];

37
 Petite précision du "[Link](…)"
 Usages : affichage à l’écran
 [Link](…) : revient à la ligne
 [Link](…) : ne revient pas à la ligne
 Différentes sorties possibles
 out : sortie standard
 err : sortie en cas d’erreur
 Tout ce que l’on peut afficher…
 Objets, nombres, booléens, caractères, …
 Tout ce que l ’on peut faire …
 Concaténation sauvage entre types et objets avec le "+"
[Link]("a=" + a + "donc a < 0 est " + a < 0);
38
 Classes et Objets

39
 Classe et définition
 Une classe est constituée
 Données ce qu'on appelle des attributs
 Procédures et/ou des fonctions ce qu'on appelle des méthodes
 Une classe est un modèle de définition pour des objets
 Ayant même structure (même ensemble d'attributs)
 Ayant même comportement (même méthodes)
 Ayant une sémantique commune
 Les objets sont des représentations dynamiques, du modèle défini
pour eux au travers de la classe (instanciation)
 Une classe permet d'instancier (créer) plusieurs objets
 Chaque objet est instance d'une classe et une seule

40
 Classe et notation UML

41
 Codage de la classe « Voiture »

public class Voiture {

private int puissance;
private boolean estDemarree;
private double vitesse;

public int deQuellePuissance() {

return puissance;
}

public void demarre() {

estDemarree = true;
}

public void accelere(double v) {

if (estDemarree) {
vitesse = vitesse + v;
}
}
}
42
 Classe et visibilité des attributs
 Caractéristique d’un attribut
 Variables « globales » de la classe
 Accessibles dans toutes les méthodes de la classe
public class Voiture {
private int puissance;
private boolean estDemarree;
private double vitesse;

public int deQuellePuissance() {

return puissance;
}
public void demarre() {
estDemarree = true;
}

public void accelere(double v) {

if (estDemarree) {
vitesse = vitesse + v;
}
}
43 }
 Distinction entre attributs et variables
 Caractéristique d’une variable
 Visible à l’intérieur du bloc qui le définit
public class Voiture {
private int puissance;
private boolean estDemarree;
private double vitesse;

public int deQuellePuissance() {

return puissance;
}
public void demarre() {
estDemarree = true;
}
public void accelere(double v) {
if (estDemarree) {
double avecTolerance;
avecTolerance = v + 25;
vitesse = vitesse + avecTolerance;
}
}
}
44
 Conventions en Java :
de la rigueur et de la classe …
 Conventions de noms
 CeciEstUneClasse
 celaEstUneMethode(…)
 jeSuisUneVariable
 JE_SUIS_UNE_CONSTANTE

 Un fichier par classe, une classe par fichier

 Classe "Voiture" décrite dans le fichier [Link]
 Il peut exceptionnellement y avoir plusieurs classes par
fichier (cas des Inner classes)

Respecter les minuscules et les majuscules des noms

45
 Objet et définition
 Un objet est instance d’une seule classe
 Se conforme à la description que celle-ci fournit
 Admet une valeur propre à l’objet pour chaque attribut déclaré
dans la classe
 Les valeurs des attributs caractérisent l’état de l’objet
 Possibilité de lui appliquer toute opération (méthode) définie
dans la Classe
 Tout objet est manipulé et identifié par sa référence
 Utilisation de pointeur caché (plus accessible que le C++)
 On parle indifféremment d’instance, de référence ou
d’objet

46
 Objet et notation UML
 maClio est une instance de la classe Voiture

47
 États des objets
 Chaque objet qui est une instance de la classe Voiture possède
ses propres valeurs d’attributs

48
 Affectation et comparaison
 Affecter un objet
 a = b : signifie a devient identique à b
 Les deux objets a et b sont identiques et toute modification de
a entraîne celle de b
 Comparer deux objets
 a == b retourne true si les deux objets sont identiques
 C’est-à-dire si les références sont les mêmes, cela ne compare
pas les attributs

49
 Affectation et comparaison
 L’objet maClio et saClio ont les mêmes attributs (états
identiques) mais ont des références différentes.
maClio != saClio

Le test de comparaison (== et !=) entre

objets ne concerne que les référence et
non les attributs !!!!

50
 Affectation et comparaison
 Recopier les attributs d’un objet "clone()"
 Les deux objets a et b sont distincts
 Toute modification de a n’entraîne pas celle de b

 Comparer le contenu des objets : "equals(Object o)"

 Renvoyer « true » si les objets a et b peuvent être considérés
comme identique au vu de leurs attributs.
Recopie et comparaison dans les
parties suivantes
51
 Structure des objets
 Un objet est constitué d’une partie « statique » et d’une
partie « dynamique »
 Partie « statique »
 Ne varie pas d’une instance de classe à une autre
 Permet d’activer l’objet
 Constituée des méthodes de la classe
 Partie « dynamique »
 Varie d’une instance de classe à une autre
 Varie durant la vie d’un objet
 Constituée d’un exemplaire de chaque attribut de la classe

52
 Cycle de vie d’un objet
 Création
 Usage d’un Constructeur
 L’objet est créé en mémoire et les attributs de l’objet sont initialisés
 Utilisation
 Usage des Méthodes et des Attributs (non recommandé)
 Les attributs de l’objet peuvent être modifiés
 Les attributs (ou leurs dérivés) peuvent être consultés

L’utilisation d’un objet non

construit provoque une exception
de type NullPointerException

 Destruction et libération de la mémoire lorsque

 Usage (éventuel) d’un Pseudo-Destructeur
 L’objet n’est plus référencé, la place mémoire occupée est récupérée

53
 Création d’objets : déroulement
 La création d’un objet à partir d’une classe est appelée une
instanciation
 L’objet créé est une instance de la classe
 Déclaration
 Définit le nom et le type de l ’objet
 Un objet seulement déclaré vaut « null »
(mot réservé du langage)
 Création et allocation de la mémoire
 Appelle de méthodes particulières : les constructeurs
 La création réserve la mémoire et initialise les attributs
 Renvoi d’une référence sur l’objet maintenant créé
monObjet != null

54
 Création d’objets : réalisation
 La création d’un nouvel objet est obtenue par l’appel à :
new Constructeur(paramètres)
 Il existe un constructeur par défaut qui ne possède pas de
paramètre (si aucun autre constructeur avec paramètre n’existe)
Les constructeurs portent le
même nom que la classe

public class TestMaVoiture {

public static void main (String[] argv) {
// Déclaration puis création
Voiture maVoiture;
maVoiture = new Voiture();
// Déclaration et création en une seule ligne
Voiture maSecondeVoiture = new Voiture();
}
}
55
 Création d’objets : réalisation
 Exemple : construction d’objets
public class TestMaVoiture {
public static void main(String[] argv) {
// Déclaration puis création
Voiture maVoiture;
maVoiture = new Voiture();
// Déclaration d’une deuxième voiture
Voiture maVoitureCopie;
// Attention!! pour l’instant maVoitureCopie vaut null
// Test sur les références.
if (maVoitureCopie == null) {

// Création par affectation d’une autre référence

maVoitureCopie = maVoiture;
// maVoitureCopie possède la même référence que maVoiture
}
// ...
}
}

56
 Le constructeur de « Voiture »
 Actuellement
 On a utilisé le constructeur par défaut sans paramètre
 On ne sait pas comment se construit la « Voiture »
 Les valeurs des attributs au départ sont indéfinies et identique pour
chaque objet (puissance, etc.)
Les constructeurs portent le même nom que la
classe et n’ont pas de valeur de retour

 Rôle du constructeur en Java

 Effectuer certaines initialisations nécessaires pour le nouvel objet créé
 Toute classe Java possède au moins un constructeur
 Si une classe ne définit pas explicitement de constructeur, un
constructeur par défaut sans arguments et qui n’effectue aucune
initialisation particulière est invoquée

57
 Le constructeur de « Voiture »
 Le constructeur de Voiture
 Initialise vitesse à zéro
 Initialise estDemaree à faux
 Initialise puissance à la valeur passée en paramètre du
constructeur
public class Voiture {
private int puissance;
private boolean estDemarree;
private double vitesse;
public Voiture(int p) {
puissance = p;
estDemarree = false;
vitesse = 0;
}
//...
}

58
 Construire une « Voiture » de 7CV
 Création de la Voiture
 Déclaration de la variable maVoiture
 Création de l’objet avec la valeur 7 en paramètre du constructeur

public class TestMaVoiture {

public static void main(String[] argv) {
// Déclaration puis création
Voiture maVoiture;

maVoiture = new Voiture(7);

Voiture maSecVoiture;
// Sous entendu qu’il existe
// explicitement un constructeur :
Voiture(int)
maSecVoiture = new Voiture(); // Erreur
}
}

59
 Constructeur sans arguments
 Utilité
 Lorsque l’on doit créer un objet sans pouvoir décider des valeurs de ses
attributs au moment de la création
 Il remplace le constructeur par défaut qui est devenu inutilisable dès qu’un
constructeur (avec paramètres) a été défini dans la classe
public class Voiture {
private int puissance;
private boolean estDemarree;
private double vitesse; public class TestMaVoiture {
public Voiture() { public static void main (String[] argv){
puissance = 4; // Déclaration puis création
estDemaree = false; Voiture maVoiture;
vitesse = 0; maVoiture = new Voiture(7);
} Voiture maSecVoiture;
public Voiture(int p) { maSecVoiture = new Voiture(); // OK
puissance = p; }
estDemaree = false; }
vitesse = 0;
}
//...
}
60
 Constructeurs multiples
 Intérêts
 Possibilité d’initialiser un objet de plusieurs manières
différentes
 On parle alors de surchage (overloading)
 Le compilateur distingue les constructeurs en fonction
 de la position des arguments
 du nombre public class Voiture {
//...
 du type public Voiture() {
puissance = 4; //...
}
Chaque constructeur possède public Voiture(int p) {
le même nom (le nom de la classe) puissance = p; //...
}
public Voiture(int p, boolean estDemaree) {
//...
}
}
61
 Accès aux attributs
 Pour accéder aux données d’un objet on utilise une notation
pointée
[Link]
public class TestMaVoiture {
public static void main (String[] argv) {
// Déclaration puis création
Voiture v1 = new Voiture();
Voiture v2 = new Voiture();
// Accès aux attributs en écriture
[Link] = 110;
// Accès aux attributs en lecture
[Link]("Puissance de v1 = " + [Link]);
}
}

Il n’est pas recommandé d’accéder

directement aux attributs d’un objet
62
 Envoi de messages : appel de méthodes
 Pour « demander » à un objet d’effectuer un traitement il faut lui
envoyer un message
 Un message est composé de trois parties :
 Une référence permettant de désigner l’objet à qui le message est
envoyé
 Le nom de la méthode ou de l’attribut à exécuter
 Les éventuels paramètres de la méthode

[Link](Paramètres)

 Envoi de message similaire à un appel de fonction

 Le code défini dans la méthode est exécuté
 Le contrôle est retourné au programme appelant

63
 Envoi de messages : appel de méthodes

Ne pas oublier les parenthèses pour les

appels aux méthodes

public class TestMaVoiture {

public static void main (String[] argv) {
// Déclaration puis création
Voiture maVoiture = new Voiture();
// La voiture démarre
[Link]();
if ([Link]() == 4) {
[Link]("Pas très Rapide…");
}
// La voiture accélère
[Link]élère(123.5);
}
}

64
 Envoi de messages : passage de
paramètres
 Un paramètre d’une méthode peut être
 Une variable de type simple
 Une référence d’un objet typée par n’importe quelle classe
 En Java tout est passé par valeur
 Les paramètres effectifs d’une méthode
 La valeur de retour d’une méthode (si différente de void)
 Les types simples
 Leur valeur est recopiée
 Leur modification dans la méthode n’entraîne pas celle de l’original
 Les objets
 Leur modification dans la méthode entraîne celle de l’original!!!
 Leur référence est recopiée et non pas les attributs

65
 Envoi de messages : passage de
paramètres
 Exemple : passage de paramètres

public class TestMaVoiture {

public static void main (String[] argv) {
// Déclaration puis création 1
Voiture maVoiture = new Voiture();
// Déclaration puis création 2
Voiture maSecondeVoiture = new Voiture();
// Appel de la méthode compare(voiture) qui
// retourne le nombre de différence
int p = [Link](maSecondeVoiture);
[Link]("Nbre différence :" + p);
}
}

66
 L’objet « courant »
 L’objet « courant » est désigné par le mot clé this
 Permet de désigner l’objet dans lequel on se trouve
 Désigne une référence particulière qui est un membre caché

Ne pas tenter d’affecter une nouvelle valeur à this !!!!

this = ... ; // Ne pas y penser

 Utilité de l’objet « courant »

 Rendre explicite l’accès aux propres attributs et méthodes
définies dans la classe
 Passer en paramètre d’une méthode la référence de l’objet
courant

67
 L’objet « courant » : attributs et méthodes
 Désigne des variables ou méthodes définies dans une classe

public class Voiture {

...
private boolean estDemarree;
private double vitesse;
public int deQuellePuissance() {
...
}
public void accelere(double vitesse) {
if (estDemarree) {
[Link] = [Link] + vitesse;
}
}
}

this n’est pas nécessaire lorsque

les identificateurs de variables ne
68 présentent aucun équivoque
 Le retour d’UML…
 Association : les objets sont sémantiquement liés
 Exemple : une Voiture est conduite par un Conducteur
 Agrégation : cycle de vie indépendant
 Exemple : une Voiture et une Galerie
 Composition : cycle de vie identiques
 Exemple : voiture possède un moteur qui dure la vie de la voiture

Les losanges sont attachés à

la classe qui contient

69
 Codage de l'association : composition
 L'objet de classe Voiture peut envoyer des messages à
l'objet de classe Moteur : Solution 1

public class Voiture {

private Moteur leMoteur;
//...
public Voiture(int p) {
leMoteur = new Moteur(p);
...
}
//...
}

70
 Codage de l'association : composition
 L'objet de classe Moteur n'envoie pas de message à l'objet
de classe Voiture : Solution 1

public class Moteur {

private int puissance;
//...
public Moteur(int p) {
puissance = p;
//...
}
//...
}

71
 Codage de l'association : composition
 Il peut être nécessaire que les deux objets en composition
s'échangent des messages : Solution 2
 L’objet Voiture « voit » l’objet Moteur

public class Voiture {

private Moteur leMoteur;
//...
public Voiture(int p) {
leMoteur = new Moteur(p,this);
...
}
//...
}

72
 Codage de l'association : composition
 Il peut être nécessaire que les deux objets en composition
s'échangent des messages : Solution 2
 L’objet Moteur « voit » l’objet Voiture

public class Moteur {

private int puissance;
private Voiture laVoiture;
//...
public Moteur(int p, Voiture v) {
puissance = p;
laVoiture = v;
//...
}
//...
}

73
 Codage de l’association : agrégation
 L'objet de classe Galerie n’envoie pas de message à l’objet de
classe Voiture

public class Voiture {

private Galerie laGalerie;
//...
public Voiture(Galerie g) {
laGalerie = g;
//...
}
//...
}

74
 Destruction et ramasse-miettes
 La destruction des objets se fait de manière implicite
 Le ramasse-miettes ou Garbage Collector se met en route
 Automatiquement
 Si plus aucune variable ne référence l’objet Préférer définir une méthode et
de l’invoquer avant que tout objet
 Si le bloc dans lequel il est défini se termine ne soit plus référencé : detruit()
 Si l’objet a été affecté à « null »
 Manuellement :
 Sur demande explicite par l’instruction « [Link]() »
 Un pseudo-destructeur « protected void finalize() » peut
être défini explicitement par le programmeur
 Il est appelé juste avant la libération de la mémoire par la machine
virtuelle, mais on ne sait pas quand
 Conclusion : pas très sûr!!!!

75
 Destruction et ramasse-miettes
public class Voiture {
private boolean estDemarree;
//...
protected void finalize() { Pour être sûr que finalize s'exécute
estDemarree = false; il faut absolument appeler
[Link](« j’arrete le explicitement [Link]()
Moteur"+estdemarre);
}
//...
}
public class TestMaVoiture {
public static void main (String[] argv) {
// Déclaration puis création de maVoiture
Voiture maVoiture = new Voiture();
[Link]();
// maVoiture ne sert plus à rien
maVoiture = null;
// Appel explicite du garbage collector
[Link]();
// Fin du programme
[Link](0);
[Link]("Message non visible");
}
76
}
 Gestion des objets
 Afficher son type et sa place mémoire : [Link]()

[Link](maVoiture) // Voiture@119c082

 Récupérer son type : méthode « Class getClass() »

[Link](); // Retourne un objet de type Class

// Class est une classe!!!
Class classVoiture = [Link]();

 Tester son type : opérateur « instanceof » mot clé « class »

if (maVoiture instanceof Voiture) {...} // C’est vrai

ou
if ([Link]() == [Link]) {...} // C’est vrai
// également

77
 Surcharge
 La surcharge (overloading) n’est pas limitée aux
constructeurs, elle est possible également pour n’importe
quelle méthode.
 Possibilité de définir des méthodes possédant le même nom
mais dont les arguments diffèrent.
 Quand une méthode surchargée est invoquée le compilateur
sélectionne automatiquement la méthode dont le nombre et
le type des arguments correspondent au nombre et au type
des paramètres passés dans l’appel de la méthode.

Des méthodes surchargées peuvent avoir des types de retour

différents à condition qu’elles aient des arguments différents
78
 Surcharge
 Exemple : une voiture surchargée
public class Voiture {
private double vitesse;
//...
public void accelere(double vitesse) {
if (estDemarree) {
[Link] = [Link] + vitesse;
}
}
public void accelere(int vitesse) {
if (estDemaree) {
[Link] = [Link] + (double)vitesse;
}
} public class TestMaVoiture {
//... public static void main (String[] argv) {
} // Déclaration puis création de maVoiture
Voiture maVoiture = new Voiture();
// Accélération 1 avec un double
[Link](123.5);
// Accélération 2 avec un entier
[Link](124);
}
79 }
 Constructeurs multiples : le retour
 Appel explicite d’un constructeur de la classe à l’intérieur
d’un autre constructeur.
 Doit se faire comme première instruction du constructeur
 Utilise le mot-clé this (paramètres effectifs)
 Exemple : public class Voiture {
//...
Implantation du constructeur public Voiture() {
this(7);
sans paramètre de Voiture }
public Voiture(int p) {
à partir du constructeur avec }
this(p, new Galerie());

paramètres public Voiture(int p, Galerie g) {

puissance = p;
moteur = new Moteur(puissance);
galerie = g;
//...
}
//...
80 }
 Encapsulation
 Possibilité d’accéder aux attributs d’une classe Java mais pas
recommandé car contraire au principe d’encapsulation.
 Les données (attributs) doivent être protégés et accessibles pour
l’extérieur par des sélecteurs.
 Possibilité d’agir sur la visibilité des membres (attributs et
méthodes) d’une classe vis à vis des autres classes.
 Plusieurs niveaux de visibilité peuvent être définis en précédant
d’un modificateur la déclaration d’un attribut, méthode ou
constructeur.
 private
 public
 protected

81
 Encapsulation : visibilité des membres
d’une classe
+ public - private
classe La classe peut être utilisée par Utilisable uniquement par les classes définies
n’importe quelle classe à l’intérieur d’une autre classe.
Une classe privée n’est utilisable que
par sa classe englobante
attribut Attribut accessible partout où Attribut restreint à la classe où est faite la
sa classe est accessible. N’est déclaration
pas recommandé du point de
vue encapsulation
méthode Méthode accessible partout Méthode accessible à
où sa classe est accessible. l’intérieur de la définition de
la classe

82
 Encapsulation
 Exemple : encapsulation
public class Voiture {
private int puissance;
//... Une méthode privée ne peut plus
public void demarre() { être invoquée en dehors du code
//...
de la classe où elle est définie
}
private void makeCombustion() {
//...
}
}

public class TestMaVoiture {

public static void main (String[] argv) {
// Déclaration puis création de maVoiture
Voiture maVoiture = new Voiture();
// Démarrage de maVoiture
[Link]();
[Link](); // Erreur
}
}
83
 Les chaînes de caractères « String »
 Ce sont des objets traités comme des types simples …
 Initialisation
String maChaine = "Bonjour!"; // Cela ressemble à un type simple

 Longueur
[Link](); // Avec les parenthèses car c'est une méthode

 Comparaison
[Link]("Bonjour!"); // Renvoi vrai

 Concaténation
String essai = "ess" + "ai";
String essai = "ess".concat("ai"); Faites attention à la comparaison
de chaînes de caractères.
maChaine == "toto";
84 Comparaison sur les références !!
 Les Chaînes modifiables « StringBuffer »
 Elles sont modifiables par insertion, ajouts, conversions, etc
 On obtient une « StringBuffer » avec ses constructeurs
StringBuffer mCM = new StringBuffer(int length);
StringBuffer mCM = new StringBuffer(String str);

 On peut les transformer en chaînes normales String

String s = [Link]();

 On peut leur ajouter n’importe (surcharge) quoi

[Link](...); // String, int, long, float, double, boolean, char

 On peut leur insérer n’importe (surcharge) quoi

[Link](int offset, ...); // String, int, long, float, double,
// boolean, char

85
 Les chaînes décomposables :
« StringTokenizer »
 Elles permettent la décomposition en mots ou éléments suivant un délimiteur
this is a test => this
is
a
test

 On obtient une « StringTokenizer » avec ses constructeurs

StringTokenizer mCM = new StringTokenize(String str); // Délimiteur = blanc
StringTokenizer rMCM = new StringTokenizer(String str, String delim);

 Exemple :
import [Link];
public class chaine {
public static void main(String[] args) {
StringTokenizer st =
new StringTokenizer("Bonjour, le monde|de|Java",", |");
while([Link]())
[Link]("Element : " + [Link]());
}
86 }
 Variables de classe
 Il peut être utile de définir pour une classe des attributs
indépendamment des instances : nombre de Voitures créées
 Utilisation des Variables de classe comparables aux « variables
globales »
 Usage des variables de classe
 Variables dont il n’existe qu’un seul exemplaire associé à sa
classe de définition
 Variables existent indépendamment du nombre d’instances de
la classe qui ont été créés
 Variables utilisables même si aucune instance de la classe
n’existe

87
 Variables de classe
 Elles sont définies comme les attributs mais avec le mot-clé
static Attention à l’encapsulation. Il
public static int nbVoitureCreees;
est dangereux de laisser cette
variable de classe en public.

 Pour y accéder, il faut utiliser non pas un identificateur mais

le nom de la classe.
[Link] = 3;

Il n’est pas interdit d’utiliser une variable de

classe comme un attribut (au moyen d ’un
identificateur) mais fortement déconseillé

88
 Constantes de classe
 Usage
 Ce sont des constantes liées à une classe
Une constante de classe est
 Elles sont écrites en MAJUSCULES généralement toujours visible
 Elles sont définies (en plus) avec le mot-clé final
public class Galerie {
public static final int MASSE_MAX = 150;
}

 Pour y accéder, il faut utiliser non pas un identificateur

d’objet mais le nom de la classe (idem variables de classe)
if ([Link]() <= Galerie.MASSE_MAX) {...}

89
 Variables et Constantes de classe
 Exemple : constantes de classe
public class Voiture {
public static final int PTAC_MAX = 3500;
private int poids;
public static int nbVoitureCreees;
public Voiture(int poids, ...) {
[Link] = poids;
nbVoitureCrees++;
//...
}
}

public class TestMaVoiture {

public static void main (String[] argv) {
// Déclaration puis création de maVoiture
Voiture maVoiture = new Voiture(2500);
//...
[Link]("Poids maxi:" +
Voiture.PTAC_MAX);
[Link]([Link]);
//...
}
90 }
 Méthodes de classe
 Usage
 Ce sont des méthodes qui ne s'intéressent pas à un objet particulier
 Utiles pour des calculs intermédiaires internes à une classe
 Utiles également pour retourner la valeur d'une variable de classe en
visibilité private
 Elles sont définies comme les méthodes d'instances, mais avec le
mot clé static
public static double vitesseMaxToleree() {
return vitesseMaxAutorisee*1.10;
}

 Pour y accéder, il faut utiliser non pas un identificateur d'objet

mais le nom de la classe (idem variables de classe)
[Link]()

91
 Méthodes de classe
 Exemple : méthode de classe
public class Voiture {
private static int nbVoitureCreees;
//...
public static int getNbVoitureCreees(){
return [Link];
}
}

public class TestMaVoiture {

public static void main (String[] argv) {
// Déclaration puis création de
maVoiture
Voiture maVoiture = new Voiture(2500);
//...
[Link]("Nbre Instance :" +
[Link]());
}
92 }
 Méthodes de classe : erreur classique
 Exemple (suite) : méthode de classe

public class Voiture {

private Galerie laGalerie;
//...
public Voiture(Galerie g) {
laGalerie = g;
//...
}
public static boolean isGalerieInstall() {
return (laGalerie != null)
}
}

On ne peut pas utiliser de

variables d'instance dans une
méthode de classe!!!!
93
 Méthodes de classe
 Rappel : les types simples (int, double, etc.) possède un alter-ego objet
disposant de méthodes de conversion
 Par exemple la classe Integer « encapsule » le type int
 Constructeur à partir d’un int ou d’une chaîne de caractères
public Integer(int value);
public Integer(String s);

 Disponibilité de méthodes qui permettent la conversion en type simple

Integer valueObjet = new Integer(123);
int valuePrimitif = [Link]();
Ou
int valuePrimitif = valueObjet; // (AutoBoxing)

 Des méthodes de classe très utiles qui permettent à partir d’une chaîne de
caractères de transformer en type simple ou type object
String maValueChaine = new String("12313");
int maValuePrimitif = [Link](maValueChaine);

Attention aux erreurs de conversion. Retour d’une

94 exception. Voir dans la dernière partie du cours
 Les tableaux en Java : application Objets
1. Déclaration  Ou 1, 2 et 3
Voiture[] monTableau; Voiture[] monTab = {
new Voiture(5),
1. Dimensionnement new Voiture(7),
monTableau = new Voiture[3]; new Voiture(8)
};
2. Initialisation
monTableau[0] = new Voiture(5);
monTableau[1] = new Voiture(7);
monTableau[2] = new Voiture(8);

for (int i = 0; i < [Link]; i++) {

[Link](monTableau[i].demarre());
}

95
 Varargs : passage de paramètres en
nombre indéfini
 Varargs est une nouveauté Java 5 permettant de passer en
paramètre un nombre indéfini de valeurs de même type.
 Avant la version Java 5, il fallait passer en paramètre un
tableau d’un type donné pour réaliser la même chose.

public ajouterPassager(String[] tab)

 La syntaxe de varargs est la suivante : utilisation de « … »

public ajouterPassager(String... tab)

96
 Varargs : passage de paramètres en
nombre indéfini
 Du côté de la méthode où le varargs est défini, les données sont manipulées comme
un tableau
public ajouterPassager(String... tab) {
for (String current : tab) {
[Link](current)
}
}

 Du côté client qui fait un appel à la méthode, les données peuvent être envoyées comme
un
 Tableau

String passagers = {"Tony", "Luck", "John"};

[Link](passagers);
 Ensemble de paramètres

[Link]("Tony", "Luck", "John");

97
 Varargs : passage de paramètres en
nombre indéfini
 Comme un varargs est considéré comme un tableau, le
contenu peut être vide
public Voiture(int... carac) { ... }
public static void main(String[] argv) {
new Voiture();
}

 Si un varargs est accompagné d’un ou plusieurs autres

paramètres, le varargs doit obligatoirement être placé en
dernier
public Voiture(String mod, int... carac) { ... }

public Voiture(int... Carac, String mod) { ... }

98
 Varargs : passage de paramètres en
nombre indéfini
 Problématiques liées à la surcharge d’une méthode utilisant
un varargs
 Dans le cas de la surcharge d’une méthode la méthode
contenant le varargs a la priorité la plus faible
public class Voiture {
public Voiture(int... carac) {
//...
}
public Voiture(int caract1, int caract2) {
//...
}
public static void main(String[] argv) {
new Voiture(12, 23);
new Voiture(12);
}
}

99