Prérequis sur la programmation

orientée objet illustrée avec JAVA

Christian Bac et Denis Conan

CSC4102

Télécom SudParis Janvier 2025

Prérequis sur la programmation orientée objet illustrée avec JAVA

Grille d’auto-évaluation des prérequis sur le langage JAVA

Voici la grille d’auto-évaluation de compétences a priori acquises dans les modules CSC3101 et PRO3600
sur la programmation en JAVA. Si certaines notions de la grille ne vous semble pas acquises, prenez connais-
sance des pages qui suivent. Les pages qui suivent ne présentent pas les derniers concepts de la grille (à partir
de « méthode polymorphique ») car nous revenons dessus dans le cours à venir.

Notions / concept de programmation 0 1 2 3 4 5

Machine virtuelle X X X X X X
JAVA Standard Development Kit : javac, java, etc. X X X X X X
if, switch X X X X X X
for, while, do while X X X X X X
Types primitifs : short, int, long, float, double, boolean, byte X X X X X X
Attribut (déclaration, définition), d’instance Versus de classe X X X X X X
final X X X X X X
static X X X X X X
Classe (abstraction, encapsulation, class) X X X X X X
Constructeur X X X X X X
this. X X X X X X
this() X X X X X X
Objet / instance X X X X X X
Référence, passage d’arguments dans les méthodes X X X X X X
new X X X X X X
Ramasse-miettes X X X X X X
Tableau ([], new) X X X X X X
Méthode (prototype, définition, paramètre, argument) X X X X X X
void X X X X X X
main X X X X X X
package, chemin de recherche X X X X X X
Surcharge (en anglais overloading) X X X X X X
Héritage (classe de base, classe dérivée) X X X X X X
extends X X X X X X
protected X X X X
Visibilité (public, private, protected, package friendly) X X X X
Méthode polymorphique X X X
Redéfinition (en anglais overriding) X X X X
super. X X X X
super() X X X X
Transtypage (en anglais cast) X X X
Upcast X X X
Downcast X X X
Liaison dynamique / tardive X X X
Classe abstraite X X X
Méthode abstraite X X X
Interface, implements X X X
Égalité (de références, d’objet), equals X X X

Table 1 : Grille d’auto-évaluation des prérequis sur la programmation JAVA

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 2

Prérequis sur la programmation orientée objet illustrée avec JAVA
' $
Sommaire

1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
4 Passage d’arguments dans les méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4 Argument variadique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
#2 5 Classes et objets en JAVA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
6 Annotation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
7 Association entre classes, multiplicité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
8 Généralisation spécialisation / Héritage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .17
9 Visibilité des attributs et des opérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
10 Organisation des sources JAVA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

& %

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 3

Prérequis sur la programmation orientée objet illustrée avec JAVA 1 Introduction
' $
1 Introduction

#3 1.1 JAVA un langage orienté objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.2 Machine Virtuelle JAVA. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .5
1.3 JAVA Standard Development Kit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

& %

' $
1.1 JAVA un langage orienté objet

■ Tout est classe sauf les types primitifs (int, float, double, etc.)
■ Tout objet (de classe) est manipulé à travers une référence
#4
■ La généralisation spécialisation, appelée héritage dans les langages de
programmation, est simple entre les classes
■ Toutes les classes dérivent/héritent de [Link]
■ L’API (en anglais, Application Programming Interface) est un ensemble de classes

& %
JAVA est un langage orienté objet. La notion de classe est centrale dans ce langage et tout le code est
contenu dans des classes. Seules les variables de type primitif ne sont pas des objets. Les types primitifs
servent à créer des variables locales dans les méthodes et des attributs pour les classes. Les objets ne sont
pas manipulés directement mais à travers des références (pointeurs dé-référencés de manière automatique).
Comme tous les langages orientés objet, JAVA supporte la généralisation spécialisation, le plus commu-
nément appélée « héritage » dans les langages de programmation. Pour simplifier la mise en œuvre, JAVA
ne permet que l’héritage simple, c’est-à-dire qu’une classe dérive d’une classe et d’une seule. En outre, JAVA
introduit le concept d’interface ; une classe peut « implémenter » plusieurs interfaces. Nous présentons les
concepts d’héritage et d’interface dans les pages qui suivent et y reviendrons dans le cours.
Toutes les classes dérivent d’une classe racine appelée [Link]. Cette classe définit des com-
portements stéréotypés dont nous reparlerons dans le cours.

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 4

Prérequis sur la programmation orientée objet illustrée avec JAVA 1 Introduction
' $
1.2 Machine Virtuelle JAVA

■ Les compilateurs génèrent du code intermédiaire (en anglais, bytecode)

■ Ce code intermédiaire est interprété par une « JAVA Virtual Machine » (JVM)
■ Modèle « compile once execute everywhere »
#5 ■ Les JAVA Virtual Machines (JVM) :
♦ s’exécutent sur les systèmes d’exploitation (par exemple avec la commande java)
♦ ou sont intégrées dans les navigateurs Web
■ Taille et domaine de valeur des types primitifs identiques sur toutes les plate-formes
■ Code source Unicode (accents et autres glyphes)
■ Bibliothèques standards riches

& %
La portabilité du code JAVA a toujours été un objectif pour ses concepteurs. Cette portabilité n’a pas
toujours été parfaite mais elle est bien plus grande que celle des langages des générations précédentes.
Un compilateur JAVA génère du code intermédiaire appelé en anglais bytecode. Ce code intermédiaire
est contenu dans un fichier dont le suffixe est .class. Un fichier .class peut être chargé par une machine
virtuelle JAVA et interprété par celle-ci. Le code intermédiaire est totalement indépendant de la machine
sur laquelle il a été généré. Il est aussi indépendant du compilateur qui l’a produit. Ce code permet de
recréer le fichier source facilement. Le modèle de compilation est appelé en anglais « compile once, execute
everywhere ».
Les tailles et les domaines de valeur des types primitifs sont identiques sur toutes les plates-formes.
Ainsi, quelle que soit l’architecture matérielle sur laquelle le programme s’exécute, un entier utilisé par
un programme JAVA possède une taille identique. Le principe du bytecode date des années 1980 avec son
introduction dans certains compilateurs du langage Pascal. Il se retrouve aussi aujourd’hui dans l’ensemble
de la chaîne de compilation de Microsoft.
Les JVM s’exécutent directement sur les systèmes d’exploitation. C’est par exemple la commande java
sous Linux. Elles peuvent aussi être embarquées dans les navigateurs Web.
Le code source des classes peut être écrit en caractères Unicode. Cependant, la collaboration entre déve-
loppeurs préconise l’utilisation de variables dont le nom est compréhensible par le plus grand nombre.

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 5

Prérequis sur la programmation orientée objet illustrée avec JAVA 1 Introduction
' $
1.3 JAVA Standard Development Kit

■ javac : compilateur
■ java : JVM interpréteur de bytecode
#6 ■ javadoc : générateur de documentation
■ javah : générateur d’entêtes pour mélange avec code natif en C (JNI)
■ javap : désassembleur de code intermédiaire pour obtenir du code JAVA
■ jdb : dévermineur
■ javakey : générateur de clés pour signer le code

& %
Le JDK permet de matérialiser les différentes parties de la chaîne de production utilisée dans le dévelop-
pement d’un programme JAVA. Ainsi, il est nécessaire de traduire les fichiers contenant du langage JAVA
en des fichiers contenant du bytecode. C’est le rôle du compilateur (javac). La commande java démarre
la machine virtuelle dans laquelle le bytecode peut s’exécuter. La commande javadoc permet d’extraire la
documentation du code pour réaliser des pages semblables à celles de la documentation des bibliothèques.

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 6

 Prérequis sur la programmation orientée objet illustrée avec JAVA
' $
2 Tableaux

■ Les tableaux sont des objets particuliers

■ Leur taille est fixe
■ Déclaration de la référence
#7 int[] arrayOfInt; // ou int arrayOfInt[];
■ Création avec association de taille
arrayOfInt = new int[42];
■ Taille
int t = [Link];
■ Erreur d’accès en cas de dépassement de taille

& %
Les tableaux sont des objets gérés de manière particulière par l’infrastructure du langage. Les variables de
type tableau sont déclarées comme des références et ne sont pas associées à l’espace mémoire correspondant.
La création d’un tableau est réalisée par l’appel du mot réservé new. C’est à ce moment que la taille du
tableau est fixée et que la référence est associée à l’objet tableau. La taille d’un tableau est connue en
accédant à l’attribut en lecture seule length. La syntaxe du langage JAVA pour accéder à un attribut ou
une méthode associée à un objet correspond à celle du langage C pour accéder à un membre d’une structure :
le point (« . ») permet de passer de la référence de l’objet à ses attributs ou méthodes.

Les tableaux sont traités de manière à empêcher les erreurs d’accès relativement au nombre d’entrées
qu’ils contiennent.
Classe [Link]
1 package eu . t e l e c o m s u d p a r i s . c s c 4 1 0 2 . p r e r e q u i s . t a b l e a u x ;
2 public c l a s s ExempleTableau {
3 public s t a t i c void main ( S t r i n g [ ] a r g s ) {
4 i n t [ ] a r r a y O f I n t ; // or i n t a r r a y O f I n t [ ] ; // d e c l a r a t i o n de l a v a r i a b l e a r r a y O f I n t
5 a r r a y O f I n t = new i n t [ 4 2 ] ; // c r e a t i o n du t a b l e a u e t a s s o c i a t i o n a a r r a y O f I n t
6 a r r a y O f I n t [ 0 ] = 3 ; // a f f e c t a t i o n d ’ un e l e m e n t du t a b l e a u
7 System . o u t . p r i n t l n ( " Array ␣ l e n g t h ␣ "+ a r r a y O f I n t . l e n g t h ) ; // o b t e n t i o n de l a t a i l l e du t a b l e a u ( 4 2 )
8 System . o ut . p r i n t l n ( a r r a y O f I n t [ 4 2 ] ) ; // i m p o s s i b l e l e v e e d ’ un e x c e p t i o n
9 }
10 }

Résultat de l’exécution :
Array length 42
Exception in thread "main" [Link]: 42
at [Link]([Link])

Depuis la version 5 du langage, JAVA fournit une nouvelle construction, appelée « for each » ou « enhanced
for », pour parcourir les éléments d’une collection, ici un tableau. Nous conseillons d’utiliser cette dernière
forme. Voici un exemple incluant les deux formes, afin que vous les compariez.
Classe [Link]
1 package eu . t e l e c o m s u d p a r i s . c s c 4 1 0 2 . p r e r e q u i s . t a b l e a u x ;
2 public c l a s s ExempledeParcoursDeTableau {
3
4 public s t a t i c void main ( S t r i n g [ ] a r g s ) {
5 // t a b l e a u
6 i n t i =0;
7 System . o ut . p r i n t l n ( " P a r c o u r s ␣ arguments ␣ de ␣ main ␣ p a r ␣ f o r ␣ a v e c ␣ i n d i c e " ) ;
8 f o r ( i =0; i < a r g s . l e n g t h ; i ++) { System . o u t . p r i n t l n ( a r g s [ i ] ) ; }
9 System . o ut . p r i n t l n ( " P a r c o u r s ␣ arguments ␣ de ␣ main ␣ p a r ␣ f o r ␣ t y p e ␣ f o r e a c h " ) ;
10 f o r ( S t r i n g s t r i n g : a r g s ) { System . o u t . p r i n t l n ( s t r i n g ) ; }
11 }
12 }

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 7

Prérequis sur la programmation orientée objet illustrée avec JAVA
' $
3 Passage d’arguments dans les méthodes
■ Par valeur : du type primitif ou de la référence (pour les objets et les tableaux)
Classe [Link]
1 package eu . t e l e c o m s u d p a r i s . c s c 4 1 0 2 . p r e r e q u i s . p a s s a g e p a r a m e t r e s ;
2 p u b l i c c l a s s ExemplePassageParametres {
3 p r i v a t e s t a t i c v o i d add ( i n t c , f i n a l i n t [ ] a s ) {
4 c++;
5 a s [ 0 ] ++;
6 System . o u t . p r i n t l n ( " add ␣ : ␣ c=" + c + " , ␣ a s [ 0 ] = " + a s [ 0 ] ) ;
7 }
#8
8 p u b l i c s t a t i c v o i d main ( f i n a l S t r i n g a r g v [ ] ) {
9 int i = 0;
10 i n t [ ] s = new i n t [ 1 0 ] ;
11 s [0] = 0;
12 add ( i , s ) ;
13 System . o u t . p r i n t l n ( " main ␣ : ␣ i=" + i + " , ␣ s [ 0 ] = " + s [ 0 ] ) ;
14 }
15 }

Résultat de l’exécution :
add : c=1, as[0]=1
main : i=0, s[0]=1
& %
Les variables de type primitif sont passées par copie de la valeur. Les variables de type tableau ou objet
sont manipulées en JAVA à travers une référence. Lors du passage d’une référence à une méthode, cette
référence permet de manipuler l’objet d’origine. Ainsi, toute modification réalisée à travers une référence
dans une méthode appelée modifie l’objet qui est référencé de manière visible par la méthode appelante.
Dans l’exemple, la modification de la copie c de la variable i dans la méthode add n’a pas de répercussion
sur la valeur de la variable i. La variable c est donc bien une variable différente de la variable i. Cette variable
a été initialisée avec la valeur de la variable i lors de l’appel. Les variables s et as (as étant une copie de
s) font référence au même tableau. Ainsi, lorsque l’entrée 0 du tableau est modifiée dans la méthode add en
utilisant la variable as, l’entrée correspondante vue à travers la variable s est modifiée de manière identique.
' $
4 Argument variadique

■ Objectif = éliminer la nécessité de regrouper manuellement les listes d’arguments

dans un tableau lors de l’invocation de méthodes acceptant des listes d’arguments
de longueur variable
#9
Classe [Link]

1 p r i v a t e s t a t i c S t r i n g format ( f i n a l String . . . strings ) {

2 Objects . requireNonNull ( s t r i n g s ) ;
3 v a r r e s u l t = new S t r i n g B u f f e r ( ) ;
4 for ( String string : s t r i n g s ) { r e s u l t . append ( " ␣ " ) . append ( s t r i n g ) ; }
5 return r e s u l t . toString ( ) ; }

& %

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 8

Prérequis sur la programmation orientée objet illustrée avec JAVA 5 Classes et objets en JAVA
' $
5 Classes et objets en JAVA

# 10 5.1 Classe, attribut, méthode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

5.2 Constructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
5.3 Attributs et méthodes de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

& %

' $
5.1 Classe, attribut, méthode

Identifiant
Nom de la classe Attributs d’instance
de la classe de l’objet

# 11 Genre classique:Genre
nom : String nom = "classique"
nbEmprunts : Integer = 0 nbEmprunts = 7

Constructeur(String n)
getNom() : String
Opérations d’instance Valeur
getNbEmprunts() : Integer
emprunter() de la classe de l’attribut
modifier(String nouveau)

& %
Ce schéma décrit la notation UML d’une classe Genre de l’étude de cas exemple « Médiathèque ». La
partie gauche contient la description des attributs et des opérations. C’est ce schéma que nous traduisons
maintenant en JAVA.
Classe [Link]
1 package eu . t e l e c o m s u d p a r i s . c s c 4 1 0 2 . p r e r e q u i s . m e d i a t h e q u e s i m p l i f i e e . c l a s s e o b j e t ;
2
3 public f i n a l c l a s s Genre {
4 private S t r i n g nom ;
5 private i n t nbEmprunts ;
6 public Genre ( f i n a l S t r i n g n ) {
7 nom = n ;
8 nbEmprunts = 0 ;
9 }

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 9

 Prérequis sur la programmation orientée objet illustrée avec JAVA 5 Classes et objets en JAVA

10 public S t r i n g getNom ( ) {
11 return nom ;
12 }
13 public i n t getNbEmprunts ( ) {
14 return nbEmprunts ;
15 }
16 public void emprunter ( ) {
17 nbEmprunts++;
18 }
19 public void m o d i f i e r ( f i n a l S t r i n g nouveau ) {
20 nom = nouveau ;
21 }
22 }

La première ligne indique que la classe appartient au paquetage (mot réservé package)
[Link]. Ensuite, la description de classe commence par une
ligne contenant le mot réservé class. Lorsque la classe est publique, le fichier qui contient celle-ci doit
porter un nom identique à la classe : dans notre cas, le fichier doit s’appeler [Link]. De manière tradi-
tionnelle, une classe commence par la description des attributs. Comme nous l’avons vu en UML, les attributs
peuvent être spécifiques à chaque objet. Ce sont des attributs d’instance. Ils peuvent aussi être partagés entre
tous les objets de la classe. Ce sont des attributs de classe ; en JAVA, ces attributs sont qualifiés de static
(cf. plus loin dans cette présentation). Par ailleurs, les attributs peuvent correspondre à des types primitifs
ou non. Dans notre cas, la variable nbEmprunts est du type primitif int. La variable nom est une référence
sur un objet de la classe [Link]. Les attributs d’instance sont le plus souvent initialisés par le
constructeur (méthode qui porte le même nom que la classe). Enfin, une classe définit les comportements de
ses objets à travers des méthodes d’instance. Une méthode d’instance réalise une opération s’appliquant sur
les attributs d’un objet. C’est le cas dans notre exemple des méthodes : getNom, getNbEmprunts, emprunter
et modifier.

La classe suivante possède une méthode main qui montre la création et la manipulation d’une instance
de la classe Genre.
Classe [Link]
1 package eu . t e l e c o m s u d p a r i s . c s c 4 1 0 2 . p r e r e q u i s . m e d i a t h e q u e s i m p l i f i e e . c l a s s e o b j e t ;
2
3 public c l a s s E x e m p l e I n s t a n c i a t i o n G e n r e {
4 public s t a t i c void main ( f i n a l S t r i n g a r g v [ ] ) {
5 Genre g ;
6 g = new Genre ( " c l a s s i q u e " ) ;
7 System . o ut . p r i n t l n ( g ) ;
8 }
9 }

Résultat de l’exécution :
[Link]@15db9742
Cet exemple montre la création d’un objet de la classe Genre. La première ligne du fichier contient une
directive import qui permet de nommer plus facilement la classe Genre. Ce code est contenu dans une classe
appelée ExempleInstanciationGenre. Cette classe est dotée d’une méthode de classe (static) publique
appelée main et recevant comme argument un tableau de chaînes de caractères. Elle sert de point d’entrée
à l’exécution du programme. À la ligne 7 est définie une variable locale appelée g qui permet de référencer
un objet de la classe Genre. L’instance est créée à la ligne 8 par l’appel du mot réservé new suivi d’un appel
au constructeur de la classe Genre. L’instance est ensuite manipulée à partir de la référence g comme dans
l’appel de la méthode println, ligne 7.

Dans le prototype de la méthode main, le mot-clé final devant la déclaration du paramètre argv indique
que, dans le corps de la méthode, argv ne peut pas changer de valeur. C’est une forme de programmation
défensive : le principe d’un paramètre est de fournir des données entrée d’une méthode ; il n’y a pas de raison
que sa valeur change ; pour plus de sûreté, nous ajoutons le mot-clé final pour que le compilateur vérifie
cela. C’est une bonne pratique que nous conseillons et sur laquelle nous reviendrons en cours.

Non utilisé dans cet exemple, la spécification de la propriété « {readOnly} » attachée à un attribut dans
le diagramme de classes ou la fiche d’une classe se traduit par la qualification final en JAVA. Par exemple,
pour rendre l’attribut nom non modifiable après sa première affectation, la déclaration devient comme suit :
private final String nom;
Dans ce cas, il faut bien sûr aussi retirer la méthode modifier.

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 10

Prérequis sur la programmation orientée objet illustrée avec JAVA 5 Classes et objets en JAVA
' $
5.2 Constructeurs
■ Début de la même classe Genre avec deux constructeurs
Classe [Link]

1 package eu . t e l e c o m s u d p a r i s . c s c 4 1 0 2 . p r e r e q u i s . m e d i a t h e q u e s i m p l i f i e e . c o n s t r u c t e u r ;
2 p u b l i c f i n a l c l a s s Genre {
3 p r i v a t e S t r i n g nom ;
4 p r i v a t e i n t nbEmprunts ;
5 p u b l i c G e n r e ( f i n a l S t r i n g nom , f i n a l i n t nbEmprunts ) {
6 t h i s . nom = nom ;
# 12 7 t h i s . nbEmprunts = nbEmprunts ;
8 }
9 p u b l i c G e n r e ( f i n a l S t r i n g nom ) {
10 t h i s ( nom , 0 ) ;
11 }

■ this permet de référencer l’instance courante

■ this est associé au concept d’auto-référence de l’objet
■ this permet de décrire un attribut ou une méthode de l’instance courante sans
ambiguïté
■ this(...) en tant que méthode fait appel à un constructeur
& %
Les constructeurs sont des méthodes particulières. Ils portent le même nom que la classe. Ils ne peuvent
pas être appelés par un appel de méthode classique. De l’extérieur de la classe, ils sont appelés en utilisant
le mot réservé new. De l’intérieur de la classe, les constructeurs peuvent s’appeler directement en utilisant
this.
Les constructeurs n’ont pas de type de retour dans leur déclaration/prototype.
Le langage JAVA permet d’avoir plusieurs méthodes portant le même nom dans une classe à la condition
que ces méthodes puissent être distinguées à l’aide de leurs paramètres. Cette propriété s’appelle la surcharge
(en anglais overloading, aussi appelée le polymorphisme ad hoc [cf. le glossaire et le « pour aller plus loin »
de la séance 3], et à ne pas confondre avec redéfinition [en anglais overriding]).
La propriété de surcharge peut être utilisée afin de proposer plusieurs façons de construire un objet d’une
classe donnée. Ainsi, nous pouvons avoir plusieurs constructeurs avec des listes de paramètres différentes.

La classe de cette exemple contient deux constructeurs. Le premier constructeur initialise les attributs
nom et nbEmprunts avec les arguments correspondants. Le second initialise l’attribut nom et laisse l’attribut
nbEmprunts à la valeur par défaut 0.

L’utilisation de this aux ligne 6 et 7 permet de distinguer les attributs de l’objet courant [Link] et
[Link], des paramètres nom et nbEmprunts du constructeur. Cette pratique est courante car les
programmeurs utilisent souvent le même nom pour l’attribut et pour le paramètre qui permet de l’initialiser.
À la ligne 11, l’instruction this(nom, 0) correspond à l’appel du constructeur de la ligne 5. Cette
pratique est courante afin de factoriser le code.

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 11

 Prérequis sur la programmation orientée objet illustrée avec JAVA 5 Classes et objets en JAVA
' $
5.3 Attributs et méthodes de classe

Attribut Audio a1 : Audio

d’instance
classification : String code = "D0001"
nbEmpruntsTotal: Integer = 0 titre = "a song of mine"
...
Attribut DURÉE: Integer = 4 * 7 classification = "classique"
# 13 de classe TARIF : Double = 1.0 nbEmpruntsTotal = 12
...
Constructeur(String code...)
Opération code = "D0002"
emprunter()
titre = "another of mine"
d’instance duréeEmprunt() : Integer
...
tarifEmprunt() : Double
getNbEmpruntsTotal() : Integer
Opération a2 : Audio
de classe

& %
Ce schéma montre une classe qui contient des attributs et des opérations soulignés. Ces attributs et
opérations sont partagés par l’ensemble des membres d’une classe. Ils sont appelés attributs ou méthodes
de classes alors que les attributs et méthodes qui ne sont pas soulignés sont appelés attributs ou méthodes
d’instance. En JAVA, le mot réservé static permet de qualifier les attributs ou méthodes de classe. Les
méthodes de classe ne peuvent accéder qu’aux attributs de classe. Les instances peuvent accéder aux attributs
de classe et peuvent invoquer les méthodes de classe. En outre, il n’est pas nécessaire d’instancier la classe
pour accéder à ses membres « statiques ».

La traduction du schéma UML est donnée dans le code ci-dessous. Lorsque la visibilité qui leur est associée
le permet, ils peuvent aussi être accédés directement en utilisant le nom de la classe suivi d’un point et du
nom de l’attribut ou de la méthode. La classe Audio définit une méthode toString qui permet d’obtenir la
représentation en chaîne de caractères d’un objet. Il est cependant nécessaire de comprendre que l’appel à la
méthode [Link] associée à un objet, fait appel à la méthode toString() de l’objet et affiche
la chaîne de caractères ainsi produite. Par ailleurs, les méthodes de classe ne sont bien sûr jamais associées
à l’auto-référence de l’objet (this).
Classe [Link]
1 package eu . t e l e c o m s u d p a r i s . c s c 4 1 0 2 . p r e r e q u i s . m e d i a t h e q u e s i m p l i f i e e . a t t r i b u t s o p e r a t i o n s d e c l a s s e ;
2
3 public f i n a l c l a s s Audio {
4 private S t r i n g c l a s s i f i c a t i o n ;
5 public s t a t i c f i n a l i n t DUREE = 4 ∗ 7 ;
6 public s t a t i c f i n a l double TARIF = 1 . 0 ;
7 private s t a t i c i n t nbEmpruntsTotal = 0 ;
8 public Audio ( f i n a l S t r i n g c l a s s i f ) {
9 this . c l a s s i f i c a t i o n = c l a s s i f ;
10 }
11 public s t a t i c i n t getNbEmpruntsTotal ( ) {
12 return nbEmpruntsTotal ;
13 }
14 public S t r i n g g e t C l a s s i f i c a t i o n ( ) {
15 return c l a s s i f i c a t i o n ;
16 }
17 public void emprunter ( ) {
18 nbEmpruntsTotal++;
19 }
20 @Override
21 public S t r i n g t o S t r i n g ( ) {
22 return " Audio ␣ [ c l a s s i f i c a t i o n =" + c l a s s i f i c a t i o n + " , ␣ nbEmpruntsTotal="
23 + nbEmpruntsTotal + " ] " ;
24 }
25 }

Voici maintenant une utilisation :

Classe [Link]

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 12

 Prérequis sur la programmation orientée objet illustrée avec JAVA 5 Classes et objets en JAVA

1 package eu . t e l e c o m s u d p a r i s . c s c 4 1 0 2 . p r e r e q u i s . m e d i a t h e q u e s i m p l i f i e e . a t t r i b u t s o p e r a t i o n s d e c l a s s e ;
2
3 public c l a s s E x e m p l e A t t r i b u t s O p e r a t i o n D e C l a s s e {
4
5 public s t a t i c void main ( S t r i n g [ ] a r g s ) {
6 Audio a1 = new Audio ( " o p e r a " ) ;
7 Audio a2 = new Audio ( " h a r d c o r e " ) ;
8 a1 . emprunter ( ) ;
9 a2 . emprunter ( ) ;
10 System . o u t . p r i n t l n ( a1 ) ;
11 System . o u t . p r i n t l n ( a2 ) ;
12 }
13
14 }

L’affichage d’une exécution montre que le nombre total de participations est identique dans les deux
objets.
Audio [classification=opéra, nbEmpruntsTotal=2]
Audio [classification=hardcore, nbEmpruntsTotal=2]

Dans les lignes de l’exemple qui suit, la classe [Link] est un bon exemple de l’usage qui peut
être fait des attributs et des méthodes de classe. Il n’est pas nécessaire d’instancier la classe pour accéder à
ses membres « statiques ». Comme son nom l’indique, la classe Math rassemble les constantes et les méthodes
mathématiques les plus utilisées.
pi = [Link]; // static attribute ’PI’
b = [Link](2.0);// method call of static ’sqrt’

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 13

5 Classes et objets en JAVA 5.3 Attributs et méthodes de classe
' $
5.3.1 Destruction des objets

■ Pas de technique particulière pour détruire un objet

■ Objet détruit lorsqu’il n’est plus référencé
■ Utilisation d’un ramasse miettes (en anglais, garbage collector )
■ Le ramasse miettes détruit les objets non référencés
# 14 ♦ La destruction est asynchrone : on ne sait pas quand la destruction est effectuée
♦ Il n’y a pas de garantie sur la destruction (le programme peut se terminer avant
que l’objet ne soit détruit)
♦ Si la classe décrit une méthode appelée finalize, cette méthode est appelée
avant la libération de la mémoire de l’objet
▶ Mais la spécification du langage ne garantit pas qu’un finalizer soit
effectivement appelé (avant la fin ou à la fin de l’exécution)

& %
Le langage JAVA a été pensé pour pallier les principales difficultés du langage C++, et en particulier, les
erreurs associées à la gestion des références vers les objets. Il est en effet difficile de garantir qu’un objet est
désalloué lorsqu’il n’est plus utilisé.
La machine virtuelle JAVA prend à sa charge la gestion des allocations et des libérations de la mémoire
en tenant à jour la liste des références vers les blocs alloués. Pour ce faire, la machine virtuelle met en œuvre
un ramasse miettes pour vérifier périodiquement que les objets alloués sont toujours référencés.
Lorsque les objets ne sont plus référencés, le ramasse miettes récupère l’espace mémoire qu’ils occupent.
Puis, il met cet espace mémoire à la disposition de la création de nouveaux objets.
Ce ramasse miettes fonctionne de manière périodique et asynchrone à l’intérieur d’un fil d’exécution séparé
de la JVM. Il n’y a pas de garantie qu’un objet soit détruit. Il est possible de déclencher le fonctionnement
du ramasse miettes par l’appel à la méthode de classe [Link]().

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 14

Prérequis sur la programmation orientée objet illustrée avec JAVA
' $
6 Annotation

■ Annotation = sucre syntaxique associant des méta-données à un élément

♦ Nom introduit par « @ » avec possiblement des arguments (nom=valeur)
♦ Annotations standards
▶ @Override : utilisée par le compilateur pour vérifier l’invariance des
# 15 prototypes lors de la redéfinition de méthode
▶ @Deprecated : utilisée par JavaDoc pour déconseiller l’utilisation de la
méthode
▶ @SuppressWarnings : utilisée par le compilateur pour ne pas générer les
avertissements concernant l’élément annoté
♦ D’autres annotations par exemple pour la programmation des tests avec JUnit
▶ Cf. cours de la séance 6

& %

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 15

 Prérequis sur la programmation orientée objet illustrée avec JAVA
' $
7 Association entre classes, multiplicité

Sens de
Association Nom de lecture de
l’association l’association
# 16
organise
Personne Scrutin
*

organise
m:Personne listeBDE:Scrutin

& %
L’extrait de diagramme de classes montre une association entre des classes Personne et Scrutin. Cette
association matérialise le fait qu’un participant peut organiser un ou plusieurs scrutins dans une application
de vote électronique. L’association est bidirectionnelle. Elle matérialise le fait qu’un scrutin est organisé par
un participant. La multiplicité indique qu’il n’y a qu’un participant.
Un exemple d’instanciation de ce diagramme de classes donne le diagramme d’objets en dessous. Dans ce
diagramme d’objets, l’objet référencé par m de la classe Personne organise le scrutin référencé par listeBDE.
Pour modéliser la relation avec les scrutins organisés, nous ajoutons à la classe Personne un tableau de
références vers des objets de la classe Scrutin. Le nombre d’entrées valides dans le tableau est contenu dans
la variable nborganisations. La taille du tableau est initialisée à 10 dans le constructeur à la ligne 8 de la
classe Personne. Les éléments du tableau sont affectés lorsque le participant organise un nouveau scrutin.
C’est la méthode organiserScrutin qui doit créer l’objet de type Scrutin. Pour que cet objet puisse initialiser
la relation dans le sens opposé, il doit recevoir la référence sur l’objet qui a fait appel à cette méthode. C’est
le rôle du second paramètre de la méthode organiserScrutin : à la ligne 11, c’est la référence de l’objet appelant
(l’auto-référence this) qui est fournie lors de l’appel.
Classe [Link]
1 package eu . t e l e c o m s u d p a r i s . c s c 4 1 0 2 . p r e r e q u i s . a s s o c i a t i o n m u l t i p l i c i t e ;
2 public c l a s s P e r s o n n e {
3 private S t r i n g nom ;
4 private S t r i n g prenom ;
5 private i n t n b P a r t i c i p a t i o n s = 0 ;
6 private i n t n b O r g a n i s a t i o n s = 0 ;
7 private S c r u t i n [ ] s c r u t i n s O r g a n i s e s ;
8 public P e r s o n n e ( f i n a l S t r i n g nom , f i n a l S t r i n g prenom ) {
9 t h i s . nom = nom ; t h i s . prenom = prenom ;
10 s c r u t i n s O r g a n i s e s = new S c r u t i n [ 1 0 ] ;
11 }
12 public S c r u t i n o r g a n i s e r S c r u t i n ( f i n a l S t r i n g nom) {
13 S c r u t i n s = new S c r u t i n ( nom , t h i s ) ;
14 scrutinsOrganises [ nbOrganisations ] = s ;
15 n b O r g a n i s a t i o n s ++;
16 return s ;
17 }
18 @Override
19 public S t r i n g t o S t r i n g ( ) {
20 return " P e r s o n n e ␣ [ nom=" + nom + " , ␣ prenom=" + prenom
21 + " , ␣ n b P a r t i c i p a t i o n s=" + n b P a r t i c i p a t i o n s
22 + " , ␣ n b O r g a n i s a t i o n s=" + n b O r g a n i s a t i o n s + " ] " ;
23 }
24 }

Dans la classe Scrutin, le constructeur reçoit en argument la référence vers l’organisateur du scrutin et
la mémorise dans l’attribut organisateur à la ligne 7.
Classe [Link]

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 16

 Prérequis sur la programmation orientée objet illustrée avec JAVA

1 package eu . t e l e c o m s u d p a r i s . c s c 4 1 0 2 . p r e r e q u i s . a s s o c i a t i o n m u l t i p l i c i t e ;
2 public c l a s s S c r u t i n {
3 private S t r i n g nomScrutin ;
4 private P e r s o n n e o r g a n i s a t e u r ;
5 public S c r u t i n ( f i n a l S t r i n g nom , f i n a l P e r s o n n e p e r s o n n e ) {
6 nomScrutin = nom ;
7 organisateur = personne ;
8 }
9 @Override
10 public S t r i n g t o S t r i n g ( ) {
11 return " S c r u t i n ␣ [ nomScrutin=" + nomScrutin + " , ␣ o r g a n i s a t e u r="
12 + organisateur + " ] " ;
13 }
14 }

La classe qui suit montre un exemple d’utilisation des deux classes.

Classe [Link]
1 package eu . t e l e c o m s u d p a r i s . c s c 4 1 0 2 . p r e r e q u i s . a s s o c i a t i o n m u l t i p l i c i t e ;
2
3 public c l a s s E x e m p l e A s s o c i a t i o n M u l t i p l i c i t e {
4 public s t a t i c void main ( f i n a l S t r i n g [ ] a r g s ) {
5 Personne p ; // r e f e r e n c e
6 p = new P e r s o n n e ( " Dupont " , " J u l i e n " ) ; // i n s t a n c e c r e a t i o n
7 S c r u t i n bde = p . o r g a n i s e r S c r u t i n ( " E l e c t i o n ␣ bde ␣ 2010 " ) ;
8 System . o u t . p r i n t l n ( bde ) ;
9 }
10 }

Une difficulté apparaît lorsque l’association est bidirectionnelle : par quoi commencer ? Comme dans
cet exemple, nous préconisons l’utilisation d’une méthode qui permet d’affecter un attribut d’une classe en
dehors du constructeur et le passage de la référence d’un des objets dans l’appel au constructeur de l’autre.

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 17

Prérequis sur la programmation orientée objet illustrée avec JAVA
' $
8 Généralisation spécialisation / Héritage

■ Une classe ne peut hériter que d’une autre classe (héritage simple)
■ Une classe hérite d’une autre par l’utilisation du mot réservé extends
■ Une classe pour laquelle aucune spécialisation n’est explicitée spécialise
# 17
implicitement la classe [Link]
■ L’opérateur instanceof permet de tester si une référence correspond à un objet
d’une classe donnée
■ Le mot réservé final utilisé devant le mot clé class interdit toute spécialisation de
la classe sur laquelle il est utilisé

& %

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 18

Prérequis sur la programmation orientée objet illustrée avec JAVA
' $
9 Visibilité des attributs et des opérations

package p1; package p2;

class C1 { class C4 extends C1 {
public int a; ...
protected int b;
}
int c; // package
private int d; class C5 {
} ...
class C2 extends C1 { }
...
}
class C3 {
...
}
# 18

■ private = seule la classe courante

a b c d
■ package = private + classes du paquetage
Accessible de C2 oui oui oui –
♦ package par défaut
■ protected = package + classes enfants item Accessible de C3 oui oui oui –
public = toutes les classes Accessible de C4 oui oui – –
Accessible de C5 oui – – –

& %

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 19

Prérequis sur la programmation orientée objet illustrée avec JAVA 9 Visibilité des attributs et des opérations
' $
9.1 Héritage et constructeur

■ Création d’un objet de classe dérivée =⇒ création de la partie de l’objet

correspondant à la classe parente
# 19 ■ Appel dans le constructeur de la classe dérivée d’un des constructeurs de la classe
parente par utilisation du mot réservé super()
♦ En première ligne du constructeur de la classe enfant
♦ Si aucun appel à super() alors appel au constructeur sans argument de la classe
parente

& %
Un objet d’une classe dérivée est un objet de la classe parente plus une partie qui correspond à la classe
dérivée. Il est donc nécessaire d’initialiser la partie provenant de la classe parente lorsque l’objet est créé.
Le constructeur de la classe dérivée doit donc faire appel au constructeur de la classe parente pour réaliser
cette initialisation. Le plus souvent un constructeur de classe dérivée reçoit un ensemble de paramètres pour
initialiser les attributs de la classe parente. Il utilise ces paramètres pour faire appel au constructeur de la
classe parente.

Voici un exemple repris de l’étude de cas exemple « Médiathèque ».

Document
code:string
titre:string
auteur:string
année:string
empruntable:booléen=F
/emprunté:booléen=F
nbEmprunts:integer=0

Vidéo
Audio
duréeFilm:integer
classification:string mentionLégale:string
nbEmpruntsTotal:integer=0 nbEmpruntsTotal:integer=0
DURÉE:integer=4*7 DURÉE:integer=2*7
TARIF:double=1.0 TARIF:double=1.5

Livre
nombrePage:integer
nbEmpruntsTotal:integer=0
DURÉE:integer=6*7
TARIF:double=0.5

La classe Document est notre classe parente. Elle contient des attributs privés : code, titre, etc. Ces
attributs sont initialisés dans le constructeur. Les autres méthodes de la classe ne sont pas décrites. Seule la
méthode toString dont nous parlerons avec le polymorphisme est définie.
Classe [Link]

1 package eu . t e l e c o m s u d p a r i s . c s c 4 1 0 2 . p r e r e q u i s . m e d i a t h e q u e s i m p l i f i e e . h e r i t a g e ;
2
3 public c l a s s Document {
4 private S t r i n g c o d e ;
5 private S t r i n g t i t r e ;
6 private S t r i n g a u t e u r ;
7 private S t r i n g annee ;
8 private boolean e m p r u n t a b l e ;

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 20

 Prérequis sur la programmation orientée objet illustrée avec JAVA 9 Visibilité des attributs et des opérations

9 private boolean emprunte ;

10 private i n t nbEmprunts ;
11 public Document ( f i n a l S t r i n g co , f i n a l S t r i n g t i t , f i n a l S t r i n g aut ,
12 f i n a l S t r i n g an ) {
13 t h i s . c o d e = co ;
14 this . t i t r e = t i t ;
15 this . auteur = aut ;
16 t h i s . annee = an ;
17 this . empruntable = f a l s e ;
18 t h i s . emprunte = f a l s e ;
19 nbEmprunts = 0 ;
20 }
21 @Override
22 public S t r i n g t o S t r i n g ( ) {
23 return " Document␣ [ c o d e=" + c o d e + " , ␣ t i t r e =" + t i t r e + " , ␣ a u t e u r="
24 + a u t e u r + " , ␣ annee=" + annee + " , ␣ e m p r u n t a b l e=" + e m p r u n t a b l e
25 + " , ␣ emprunte=" + emprunte + " , ␣ nbEmprunts=" + nbEmprunts + " ] " ;
26 }
27 }

La classe Audio est une spécialisation de la classe Document. Elle contient un attribut privé supplé-
mentaire : classification. Cet attribut privé est initialisé dans le constructeur. Le constructeur de la classe
Audio reçoit des paramètres pour initialiser ses attributs et des paramètres qu’il utilise pour faire appel au
constructeur de la classe Document. Comme pour la classe parente, seule la méthode toString est définie.
Classe [Link]
1 package eu . t e l e c o m s u d p a r i s . c s c 4 1 0 2 . p r e r e q u i s . m e d i a t h e q u e s i m p l i f i e e . h e r i t a g e ;
2
3 public f i n a l c l a s s Audio extends Document {
4 private S t r i n g c l a s s i f i c a t i o n ;
5 public s t a t i c f i n a l i n t DUREE = 4 ∗ 7 ;
6 public s t a t i c f i n a l double TARIF = 1 . 0 ;
7 public Audio ( f i n a l S t r i n g code , f i n a l S t r i n g t i t r e , f i n a l S t r i n g a u t e u r ,
8 f i n a l S t r i n g annee , f i n a l S t r i n g c l a s s i f ) {
9 super ( code , t i t r e , a u t e u r , annee ) ;
10 this . c l a s s i f i c a t i o n = c l a s s i f ;
11 }
12 @Override
13 public S t r i n g t o S t r i n g ( ) {
14 return " Audio ␣ [ c l a s s i f i c a t i o n =" + c l a s s i f i c a t i o n + " , ␣ t o S t r i n g ()= "
15 + super . t o S t r i n g ( ) + " ] " ;
16 }
17 }

Voici une utilisation des classes parentes et dérivées.

Classe [Link]

1 package eu . t e l e c o m s u d p a r i s . c s c 4 1 0 2 . p r e r e q u i s . m e d i a t h e q u e s i m p l i f i e e . h e r i t a g e ;
2
3 public c l a s s E x e m p l e H e r i t a g e {
4 public s t a t i c void main ( f i n a l S t r i n g [ ] a r g s ) {
5 Document s e i g n e u r = new Document ( " C007 " ,
6 " Le ␣ s e i g n e u r ␣ d e s ␣ anneaux " , " T o l k i e n " , " 1950 " ) ;
7 Audio wyatt = new Audio ( " C003 " , " Rock ␣ bottom " ,
8 " Rober ␣Wyatt " , " 1973 " , " P r o g r e s s i f " ) ;
9 System . o u t . p r i n t l n ( " s e i g n e u r ␣ e s t ␣un␣Document␣ : ␣ "
10 + ( s e i g n e u r i n s t a n c e o f Document ) ) ;
11 System . o u t . p r i n t l n ( " s e i g n e u r ␣ e s t ␣un␣ Audio ␣ : ␣ "
12 + ( s e i g n e u r i n s t a n c e o f Audio ) ) ;
13 System . o ut . p r i n t l n ( " wyatt ␣ e s t ␣un␣Document␣ : ␣ "
14 + ( wyatt i n s t a n c e o f Document ) ) ;
15 System . o u t . p r i n t l n ( " wyatt ␣ e s t ␣un␣ Audio ␣ : ␣ "
16 + ( wyatt i n s t a n c e o f Audio ) ) ;
17 }
18 }

Résultat de l’exécution :
seigneur est un Document : true
seigneur est un Audio : false
wyatt est un Document : true
wyatt est un Audio : true

Dans cet exemple, la classe Audio étend (avec le mot-clé extends) la classe Document. Le constructeur de
la classe Audio fait appel au constructeur de la classe Document à la ligne 9 par l’utilisation du mot réservé
super. Le résultat de l’exécution permet de vérifier qu’un objet de la classe Audio est bien une instance de
la classe Document.

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 21

Prérequis sur la programmation orientée objet illustrée avec JAVA
' $
10 Organisation des sources JAVA

■ Unité de compilation
♦ Un fichier source JAVA = une unité de compilation
♦ Recommandation : une seule classe par fichier source
♦ Obligation : nom du fichier source = nom de sa classe publique
■ Paquetage
♦ Paquetage = regroupement de classes dans un espace de nommage
# 20
♦ Noms des classes : « [Link] »
♦ Espace de nommage associé à la compilation et à l’exécution
▶ Classe Document du paquetage
[Link] doit être dans un fichier
correspondant au chemin
prerequis/mediathequesimplifiee/heritage/[Link]
♦ Ceci permet au compilateur et à la JVM de trouver les fichiers compilés
♦ Mot réservé package : nom de paquetage des classes dans l’unité de compilation

& %
Un fichier source en JAVA correspond à une unité de compilation. Une unité de compilation n’est com-
pilable que si le compilateur dispose de l’ensemble des classes utilisées dans ce fichier. Ceci peut conduire
un compilateur à compiler plusieurs classes lors d’une demande de compilation d’une seule classe. Il est
fortement recommandé d’avoir une seule classe par fichier source. Un fichier source contenant une classe
publique doit porter le même nom que cette classe.

Les paquetages permettent de regrouper un ensemble de classes dans un espace de nom-

mage. Les noms des classes suivent le schéma « [Link] ». Cet es-
pace de nommage est associé à la compilation et à l’exécution. La classe Document du paquetage
« [Link] » doit être dans un fichier correspondant au chemin
« prerequis/mediathequesimplifiee/heritage/[Link] ». Ceci permet au compilateur et à la
JVM de trouver les fichiers compilés. Le mot réservé package permet d’indiquer le nom de paquetage pour
chaque unité de compilation.

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 22

Prérequis sur la programmation orientée objet illustrée avec JAVA 10 Organisation des sources JAVA
' $
10.1 Chemin de recherche et exécution d’un programme JAVA

■ Chemin de recherche
♦ Variable d’environnement CLASSPATH = liste des répertoires de recherche pour le
compilateur et la JVM
# 21 ♦ Noms des classes complets contiennent le nom de paquetage
♦ import : permet d’établir un alias
♦ API JAVA : organisée en paquetages ([Link], [Link], etc.)
■ Exécution d’un programme JAVA
♦ Point d’entrée public static void main(String args[]) dans une classe
♦ Classes chargées à la demande (en anglais, dynamic loading)

& %
Les répertoires dans lesquels le compilateur et la JVM cherchent les paquetages sont décrits dans une
variable d’environnement appelée CLASSPATH. À l’extérieur d’un paquetage, les noms des classes sont com-
posés du nom de paquetage, d’un point et du nom de la classe. Un nom de paquetage peut être composé
de plusieurs parties séparées elles aussi par des points. L’instruction import permet d’utiliser le nom de la
classe importée sans le nom du paquetage en préfixe. L’API JAVA est organisée en paquetages ([Link],
[Link], etc.).

Les caractéristiques de la machine virtuelle JAVA font qu’il n’existe pas d’équivalent au programme en
binaire exécutable obtenu dans une chaîne de compilation classique et en particulier en langage C. En effet,
pour qu’un programme JAVA soit exécutable, il suffit d’un point d’entrée et d’un ensemble de classes. Le
point d’entrée est matérialisé par la méthode main. Cette méthode contient les instructions de départ du
programme. La machine virtuelle charge dynamiquement les classes qui sont référencées à partir de cette
méthode. Le chargement des classes de l’API ne différe pas de celui des autres classes.

Voici un exemple.
• CLASSPATH : CLASSPATH=/src:/java
• Fichier eu/telecomsudparis/csc4102/prerequis/mediathequesimplifiee/organisationsources/[Link]
contenant le code suivant :
1 package eu . t e l e c o m s u d p a r i s . c s c 4 1 0 2 . p r e r e q u i s . m e d i a t h e q u e s i m p l i f i e e . o r g a n i s a t i o n s o u r c e s ;
2
3 import eu . t e l e c o m s u d p a r i s . c s c 4 1 0 2 . p r e r e q u i s . m e d i a t h e q u e s i m p l i f i e e . c l a s s e o b j e t . Genre ;
4
5 public abstract c l a s s Document {
6 private S t r i n g c o d e ;
7 private S t r i n g t i t r e ;
8 private S t r i n g a u t e u r ;
9 private S t r i n g annee ;
10 private Genre g e n r e ;
11 private boolean e m p r u n t a b l e ;
12 private boolean emprunte ;
13 private i n t nbEmprunts ;
14 protected Document ( f i n a l S t r i n g co ,
15 f i n a l S t r i n g t i t , f i n a l S t r i n g aut , f i n a l S t r i n g an , f i n a l Genre g )
16 {
17 t h i s . c o d e = co ;
18 this . t i t r e = t i t ;
19 this . auteur = aut ;
20 t h i s . annee = an ;
21 this . genre = g ;
22 this . empruntable = f a l s e ;
23 t h i s . emprunte = f a l s e ;
24 nbEmprunts = 0 ;

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 23

Prérequis sur la programmation orientée objet illustrée avec JAVA 10 Organisation des sources JAVA

25 }
26 public f i n a l S t r i n g getCode ( ) { return c o d e ; }
27 public f i n a l S t r i n g g e t T i t r e ( ) { return t i t r e ; }
28 public f i n a l S t r i n g g e t A u t e u r ( ) { return a u t e u r ; }
29 public f i n a l S t r i n g getAnnee ( ) { return annee ; }
30 public f i n a l Genre g e t G e n r e ( ) { return g e n r e ; }
31 public f i n a l i n t getNbEmprunts ( ) { return nbEmprunts ; }
32 public f i n a l void metEmpruntable ( ) { }
33 public f i n a l void m e t C o n s u l t a b l e ( ) { }
34 public f i n a l boolean e s t E m p r u n t a b l e ( ) { return e m p r u n t a b l e ; }
35 public void emprunter ( ) { }
36 public f i n a l boolean estEmprunte ( ) { return emprunte ; }
37 public void r e s t i t u e r ( ) { }
38 }

Pour compiler le fichier [Link], le compilateur recherche le fichier source Genre du paquetage
[Link] à partir des chemins décrits
dans le CLASSPATH. Il commence donc par chercher les sous-répertoires eu, eu/telecomsudparis, etc. dans le
répertoire /src. Il ne trouve pas ce sous-répertoire et passe au chemin suivant. Il cherche dans /java et trouve
un répertoire eu/telecomsudparis/csc4102/prerequis/mediathequesimplifiee/organisationsources/[Link].
Dans ce répertoire il trouve le fichier class [Link] ou il compile le fichier [Link] pour obtenir le
fichier .class. Avec ce fichier .class ainsi que les autres, il est à même de compiler le fichier [Link].

Télécom SudParis — C. Bac, D. Conan — Janvier 2025 — CSC4102 24