Programmation Orienté Objet (POO)

Language JAVA

WEB Design et Marketing Digital

Semestre 3

[Link]
[Link]@[Link]

2025/2026
 Organisation du cours
■ Nous verrons
– Rappel: POO de base
■ Caractéristiques de Java et son environnement de développement
■ Structures fondamentales
■ La programmation par objets en Java
– Héritage
– Polymorphisme
– Rappel: POO Avancée
■ Les exceptions, les entrées / sorties en Java
■ La programmation des interfaces graphiques en Java
■ Les collections en Java
■ L‟accès aux bases de données,…..
■ Les threads
– Mini projet

2
Les outils
■ La notation UML
■ Langage de programmation : Java
■ IDE : IntelliJ ou autre (Eclipse, NetBeans, etc.)
■ Les tests : Junit
■ Versioning : Git et GitHub

3
Evaluation
■ Contrôles Continus
– Des travaux à rendre sur classroom
– Projet par équipe de 3 à 4 étudiants
■ les notes seront individuelles
■ but : travailler en équipe,
■ période de réalisation :
■ soutenances le …..

■ Examen
– Durée de 1h30min / 2h
– questions de cours + exercices

4
Caractéristiques du langage
Java
 Caractéristiques du langage Java
■ Simple
– Apprentissage facile
■ faible nombre de mots-clés
■ simplifications des fonctionnalités essentielles
– Développeurs opérationnels rapidement
– Pas de notion de pointeurs
– Ni la notion d'héritage multiple et la surcharge
des opérateurs
■ Familier
– Syntaxe proche de celle de C/C++

6
 Caractéristiques du langage Java
■ Orienté objet
– Java ne permet d'utiliser que des objets (hors les types de
base)
– Java est un langage objet de la famille des langages de
classe
comme C++
– Les grandes idées reprises sont : encapsulation, dualité
classe
/instance, attribut, méthode / message, visibilité, dualité
interface/implémentation, héritage simple, redéfinition
de méthodes, polymorphisme
– Chaque fichier source contient la définition d'une ou
plusieurs classes qui sont utilisées les unes avec les 7
Caractéristiques du langage Java
■ Java est fortement typé
– Toutes les variables sont typées et il n'existe pas de
conversion automatique qui risquerait une perte de données.
■ Fiable
– Gestion automatique de la mémoire
■ L‟allocation de la mémoire pour un objet est automatique à sa
création et Java récupère automatiquement la mémoire
inutilisée suite à la destruction des objets
– Gestion des exceptions
– Sources d'erreurs limitées
■ typage fort, pas d'héritage multiple, pas de manipulations
de pointeurs, etc.
– Vérifications faites par le compilateur facilitant une
plus grande rigueur du code 8
Caractéristiques du langage Java
■ Java est indépendant de toute plate-forme
– Il est possible d'exécuter des programmes Java sur
tous les environnements qui possèdent une Java
Virtual Machine.
■ JAVA autorise le multitâche (multithreading)-
– Exécution de plusieurs processus effectuant chacun une
tâche différente
– Mécanismes de synchronisation
– Fonctionnement sur des machines multiprocesseurs

9
 Caractéristiques du langage Java
■ JAVA contient une très riche bibliothèque de
classes (Packages) qui permettent de :
– Créer des interfaces graphiques
– Utiliser les données multimédia
– Communiquer à travers les réseaux

■ JAVA peut être utilisé sur INTERNET

– Les programmes Java s‟exécutant sur les pages Web
■ JAVA est gratuit

10
 Caractéristiques du langage Java
■ Java est interprété
– Le code source est compilé en pseudo code ou byte
code puis exécuté par un interpréteur Java : la Java
Virtual Machine
on Exécuti
Avant ex écution

Autres byte code

Fichier
Byte code Machine virtuelle
de code Compilation Java (JVM)
Java

javac [Link] jav a

[Link]

11
 L’API de
Java
■ Java fournit de nombreuses librairies de classes
remplissant des fonctionnalités très diverses :
c'est l'API Java
– API (Application and Programming Interface /Interface
pour la programmation d'applications) : Ensemble de
bibliothèques permettant une programmation plus aisée
car les fonctions deviennent indépendantes du matériel.
■ Ces classes sont regroupées, par catégories, en
paquetages (ou "packages").

12
L’API de Java
■ Les principaux paquetages
– [Link] : structures de données classiques
– [Link] : entrées / sorties
– [Link] : chaînes de caractères, interaction avec l'OS,
threads
– [Link] : les applets sur le web
– [Link] : interfaces graphiques, images et dessins
– [Link] : package récent proposant des composants «
légers » pour la création d‟interfaces graphiques
– [Link] : sockets, URL
– [Link] : Remote Method Invocation (pas abordé dans ce
cours)
– [Link] : fournit le package JDBC
13
Editions Java
■ Java est disponible dans plusieurs éditions utilisées à
des fins diverses.
– Java Standard Edition (Java SE), Contient les classes qui
forment le cœur du langage Java
– Java Entreprise Edition (Java EE) pour le développement
d‟applications d‟entreprise. Elle contient les classes J SE plus
d‟autres classes pour le développement d‟applications
d‟entreprise.
– Java Micro Edition (Java ME). pour les produits
d‟électronique grand public (téléphones portables,..) dans ce cas
seule une petite partie du langage est utilisée.
■ Chaque édition contient un kit de développement
JavaJDK) pour développer des applications et un
environnement d’exécution Java (JRE) pour les
exécuter.
14
 Outil de développement : le
JDK
■ Environnement de développement fourni par Sun
■ JDK signifie Java Development Kit (Kit de développement
Java). Un ensemble de bibliothèques logicielles de base du
langage de programmation Java
■ Ce kit est librement téléchargeable sur le site web de
Sun [Link]
■ Il contient :
– les classes de base de l'API java (plusieurs centaines),
– la documentation au format HTML
– le compilateur : javac
– la JVM (machine virtuelle) : java
– le générateur de documentation : javadoc
– etc.
15
 Outil de développement : le
JRE
■ Le JRE (Java Runtime Environment) contient uniquement
l'environnement d'exécution de programmes Java.
■ Le JDK contient lui même le JRE.
■ Le JRE seul doit être installé sur les machines où
des applications Java doivent être exécutées.

16
 Editeur de code java: IDE (Integrated Development
Environment)

■ Jedit [Link]

■ Eclipse [Link]

■ NetBeans [Link]

■ Jcreator [Link]

■ Android Studio

■ IntelliJ
Bases du langage
Les commentaires
■ /* commentaire sur une ou plusieurs lignes */
– Identiques à ceux existant dans le langage C
■ // commentaire de fin de ligne
– Identiques à ceux existant en C++
■ /** commentaire d'explication */
– Les commentaires d'explication se placent généralement
juste avant une déclaration (d'attribut ou de méthode)
– Ils sont récupérés par l'utilitaire javadoc et inclus dans la
documentation ainsi générée.

19
Instructions, blocs et blancs
■ Les instructions Java se terminent par un ;
■ Les blocs sont délimités par :
{ pour le début de bloc
} pour la fin du bloc
– Un bloc permet de définir un regroupement
d‟instructions.
– La définition d‟une classe ou d‟une méthode se fait
dans un bloc.
■ Les espaces, tabulations, sauts de ligne sont
autorisés. Cela permet de présenter un code
plus lisible.
20
 Point d’entrée d’un programme
■
Java
Pour pouvoir faire un programme exécutable il
faut toujours une classe qui contienne une
méthode particulière, la méthode « main »
– c‟est le point d‟entrée dans le programme : le
microprocesseur sait qu‟il va commencer à exécuter
les instructions à partir de cet endroit

public static void main(String arg[ ])

{
… //
}

21
Exemple
Fichier [Link]
La classe est
public class Bonjour l’unité de
base de nos
{ //Accolade débutant la classe Bonjour programmes.
Le mot clé en
Java pour
public static void main(String args[]) définir une
classe est
{ //Accolade débutant la méthode main class
/* Pour l’instant juste une instruction
*/ [Link](“bonjour”);

} //Accolade fermant la méthode main

} //Accolade fermant la classe
Bonjour
22
Exemple
Fichier [Link]

public class Bonjour

{
public static void main(String
args[])
{
[Link](“bonjour”)
;
}
} Les instructions se terminent
par des ;

23
Compilation et exécution
Le nom du fichier est nécessairement
Fichier [Link] celui de la classe avec l’extension
.java en plus Java est sensible à la
casse des lettres.

public class Bonjour

{
public static void main(String[] args)
{
[Link](“bonjour”);
}
}
24
 Compilation et exécution
■ Pour résumer, dans une console DOS, si j’ai un fichier
[Link] pour la classe Bonjour :
– javac [Link]
■ Compilation en bytecode java
■ Indication des erreurs de syntaxe éventuelles
■ Génération d‟un fichier [Link] si pas d‟erreurs
– java Bonjour
■ Java est la machine virtuelle
■ Exécution du bytecode
■ Nécessité de la méthode main, qui est le point d‟entrée dans
le programme

25
 Identificateurs
■ On a besoin de nommer les classes, les variables,
les constantes, etc. ; on parle d’identificateur.
■ Les identificateurs commencent par
une lettre, _ ou $
Attention : Java distingue les majuscules des minuscules
■ Conventions sur les identificateurs :
– Si plusieurs mots sont accolés, mettre une majuscule
à chacun des mots sauf le premier.
■ exemple : uneVariableEntiere
– La première lettre est majuscule pour les classes et
les interfaces
26
■ exemples : MaClasse, UneJolieFenetre
Identificateurs
■ Conventions sur les identificateurs :
– La première lettre est minuscule pour les
méthodes, les attributs et les variables
■ exemples : setLongueur, i, uneFenetre
– Les constantes sont entièrement en majuscules
■ exemple : LONGUEUR_MAX

27
Les mots réservés de Java
abstract default goto null synchronize
d
boolean do if package this

break double implements private throw

byte else import protected throws

case extends instanceof public transient

catch false int return true

char final interface short try

class finally long static void

continue float native super volatile

const for new switch while

28
Les types de bases (1)
■ En Java, tout est objet sauf les types de base.
■ Il y a huit types de base :
– un type booléen pour représenter les variables ne pouvant prendre
que 2 valeurs (vrai et faux, 0 ou 1, etc.) : boolean avec les valeurs
associées true et false
– un type pour représenter les caractères : char
– quatre types pour représenter les entiers de divers taille :
byte, short, int et long
– deux types pour représenter les réels : float et double
■ La taille nécessaire au stockage de ces types est
indépendante de la machine.

29
Les types de bases : les entiers

30
Les types de bases : les entiers
■ Notation
– 2: entier normal en base décimal, on utilise les 10 chiffres
(0 à 9)
– 2L: entier au format long en base décimal
– 0xF: entier en valeur hexadécimale (base 16)
■ Opérations sur les entiers
– opérateurs arithmétiques +, -, *
– / :division entière si les 2 arguments sont des entiers
– % : reste de la division entière
■ exemples :
– 15 / 4 donne 3
– 15 % 2 donne 1
31
 Les types de bases : les entiers
■ Opérations sur les entiers (suite)
– les opérateurs d‟incrémentation ++ et de décrémentation et - -
■ ajoute ou retranche 1 à une variable
int n = 12;
n ++; //Maintenant n vaut 13
■ n++; « équivalent à » n =
n+1; n--; « équivalent à »
n = n-1;
■ 8++; est une instruction illégale
■ peut s‟utiliser de manière suffixée : ++n. La différence avec la
version préfixée se voit quand on les utilisent dans les expressions.
En version suffixée la (dé/inc)rémentation s‟effectue en premier

int m=7; int n=7;

int a=2 * ++m; // a =16, m = 8
int b=2 * n++; // b = 14, n = 8
32
Les types de bases : les réels
■ Les réels
– float : codé sur 32 bits, peuvent représenter des nombres allant de
-1035 à + 1035
– double : codé sur 64 bits, peuvent représenter des nombres allant
de -10400 à +10400
■ Notation
– 4.55 ou 4.55D est un réel double précision
– 4.55f est un réel simple précision: le f signale que c'est un float
– 4.25E4 qui est équivalent à b=4.25e4 c'est la notation
exponentielle ou scientifique (= 42500.0).

33
Les types de bases : les réels
■ Les opérateurs
– opérateurs classiques +, -, *, /
– attention pour la division :
– 15 / 4 donne 3 division entière
– 15 % 2 donne 1
– 11.0 / 4 donne 2.75
(si l‟un des termes de la division est un réel, la
division retournera un réel).

– puissance : utilisation de la méthode pow de la

classe Math.
– double y = [Link](x, a) équivalent à x^a, x et a étant
de type double
34
Les types de bases : les booléens
■ Les booléens
■ boolean
contient soit vrai (true) soit faux (false)
■ Les opérateurs logiques de comparaisons
■ Egalité : opérateur ==
■ Différence : opérateur !=
■ supérieur et inférieur strictement à : opérateurs
> et <
■ supérieur et inférieur ou égal :
opérateurs >= et <=
35
Les types de bases: les booléens
■ Note:
boolea
n x; x=
true;
x= false;
x= (5==5); // l ‟expression (5==5) est évaluée puis la
valeur de l‟expression sera affectée à x qui vaut alors vrai
x= (5!=4); // x vaut vrai, ici on obtient vrai car 5 est différent
de 4 x= (5>5); // x vaut faux, 5 n'est pas supérieur strictement à
5
x= (5<=5); // x vaut vrai, 5 est bien inférieur ou égal à 5 36
Les types de bases : les booléens
■ Les autres opérateurs logiques
– et logique : &&
– ou logique : ||
– non logique : !
– Exemples : si a et b sont 2 variables booléennes
boolean a,b,
c; a= true;
b= false;
c= (a && b); // c vaut
c= (a || b); false
c= !(a && // c vaut true
b); c=!a; // c vaut true
// c vaut 37
 Les types de bases : les caractères
■ Les caractères
– char : contient une seule lettre
– le type char désigne des caractères en représentation
Unicode
■ Codage sur 2 octets contrairement à ASCII/ANSI codé
sur 1 octet. Le codage ASCII/ANSI est un sous-
ensemble d‟Unicode
■ Notation hexadécimale des caractères Unicode de
„ \u0000‟ à „ \uFFFF‟.
■ Plus d‟information sur Unicode à : [Link]

38
 Les types de bases
int x = 0, y = 0; float
z = 3.1415F;
double w = 3.1415;
long t = 99L;
boolean test = true;
char c = 'a';

■ Remarque importante :
En Java, une variable n‟ayant pas encore reçu de valeur ne peut pas être
utilisée, //erreur de compilation.
Exemple
int n ;
[Link] ("n " + n ) ; // erreur de compilation : la valeur de n
// n’est pas définie ici

39
Conversion des types primitifs
■ Il est possible de convertir une valeur codée dans un type donné
vers un type de plus grande capacité et ceci sans perte de précision.
On peut imaginer la conversion comme ceci:
byte -> short -> int -> long -> float -> double
■ La conversion de type de données de la gauche vers la droite (le sens
de l'élargissement) s'effectue automatiquement, tandis que dans le
sens inverse (ou sens de la restriction), il est nécessaire de passer par
une conversion explicite.
■ // Conversion automatique
float x = 10
double y;
y=x ;

40
Conversion des types primitifs
// Conversion explicite
float x ; double
y=10.5; x=y ;
//erreur
x=(float)y; // convertion (cast)
■ Il est également possible de placer des caractères spéciaux (l, f, et d)
immédiatement après le littéral numérique afin d'effectuer une opération de
Conversion.
– // Conversion d'une valeur numérique en type long
long a = 199999999999999999L;
- // Conversion d'une valeur numérique en type float
float b = 3.0F;

float x = b + 24F;

47
 Constantes
■ Java permet de déclarer que la valeur d‟une variable ne doit pas être
modifiée pendant l‟exécution du programme.
■ Les constantes peuvent être déclarées dans les classes ou dans les
méthodes en utilisant le mot-clé final.
final int CODE =
1537503; final double PI
= 3.14;
Final String COULEUR_NOIRE = "#000000";

La tentative de modifier une constante dans le programme entraînera

une erreur lors de la compilation.

42
Les structures de contrôles
■ Les structures de contrôle classiques
existent en Java :
– if, else
– switch, case, default, break
– for
– while
– do, while

43
 Les structures de contrôles : if /
■
else
Instructions conditionnelles
– Effectuer une ou plusieurs instructions seulement si une
certaine condition est vraie
if (condition) instruction;
et plus généralement :if (condition)
{ bloc d’instructions}
condition doit être un booléen ou renvoyer une valeur booléenne
– Effectuer une ou plusieurs instructions si une certaine
condition est vérifiée sinon effectuer d‟autres instructions if
(condition) instruction1; else instruction2;
et plus généralement if (condition) { 1er bloc d’instructions}
else {2ème bloc d’instruction}

44
 Les structures de contrôles : if /
else
[Link]

import [Link].*;

public class Max

{
public static void main(String args[])
{
Console console = [Link]();
int nb1 = [Link]([Link]("Entrer un entier:"));
int nb2 = [Link]([Link]("Entrer un autre entier:"));
if (nb1 > nb2)
[Link]("l'entier le plus grand est "+ nb1);
else
[Link]("l'entier le plus grand est "+ nb2);
}
}

45
Les structures de contrôles : while
■ Boucles indéterminées
– On veut répéter une ou plusieurs instructions un
nombre indéterminés de fois : on répète
l‟instruction ou le bloc d‟instruction tant que une
certaine condition reste vraie
– nous avons en Java une première boucle while (tant
que)
■ while (condition) {bloc d’instructions}
■ les instructions dans le bloc sont répétées tant
que la condition reste vraie.
■ On ne rentre jamais dans la boucle si la
condition est fausse dès le départ
46
 Les structures de contrôles : while

■ Boucles indéterminées
– un autre type de boucle avec le while:
■ do {bloc d’instructions} while (condition)
■ les instructions dans le bloc sont répétées tant
que la condition reste vraie.
■ On rentre toujours au moins une fois dans la
boucle : la condition est testée en fin de
boucle.

47
 Les structures de contrôles : while
[Link]

import [Link].*;

public class Facto1

{
public static void main(String args[])
{
int n, result,i;
n = [Link]([Link]().readLine("Entrer une valeur pour n:"));
result = 1; i = n;
while (i > 1)
{
result = result * i;
i--;
}
[Link]("la factorielle de "+n+" vaut "+result);
}
}
48
 Les structures de contrôles : for
■ Boucles déterminées
– On veut répéter une ou plusieurs instructions un nombre
déterminés de fois : on répète l‟instruction ou le bloc
d‟instructions pour un certain nombre de pas.
– La boucle for
for (int i = 1; i <= 10; i++)
[Link](i); //affichage des nombres de 1 à 10
– une boucle for est en fait équivalente à une boucle while
for (instruction1; expression1; expression2) {bloc}
… est équivalent à …
instruction 1;
while (expression1)
{bloc; expression2}
49
Les structures de contrôles : for
[Link]

import [Link].*;

public class Facto2

{
public static void main(String args[])
{
int n, result,i;
n = [Link]([Link]().readLine("Entrer une valeur pour n:"));
result = 1;
for(i =n; i > 1; i--)
{
result = result * i;
}
[Link]("la factorielle de "+n+" vaut "+result);
}
}

50
 Les structures de contrôles : switch
■ Sélection multiples
– l‟utilisation de if / else peut s‟avérer lourde quand on
doit traiter plusieurs sélections et de multiples
alternatives
– pour cela existe en Java le switch / case assez identique à
celui de C/C++
– La valeur sur laquelle on teste doit être un char ou un entier
– L‟exécution des instructions correspondant à une
alternative commence au niveau du case correspondant
et se termine à la rencontre d‟une instruction break ou
arrivée à la fin du switch
51
 Les structures de contrôles (10) :
[Link]
switch
import [Link].*; Variable contenant la
valeur que l’on veut tester.
public class Alternative
{ Première alternative :
public static void main(String args[]) on affiche Un et on sort
{ du bloc du switch au break;
int nb = [Link]([Link]().readLine("Entrer une valeur pour n:"));
switch(nb)
{ Deuxième alternative :
case 1: on affiche Deux et on sort
[Link]("Un"); break; du bloc du switch au break;
case 2:
[Link]("Deux"); break;
default:
[Link]("Autre nombre"); break; Alternative par défaut:
} on réalise une action
} par défaut.
} 58
Les tableaux
■ Les tableaux permettent de stocker plusieurs valeurs de
même type dans une variable.
– Les valeurs contenues dans la variable sont repérées par un indice
– En langage java, les tableaux sont des objets
■ Déclaration
– int tab [ ];
String chaines[ ];
■ Création d'un tableau
■ tab = new int [20]; // tableau de 20 int
■ chaines = new String [100]; // tableau de 100 chaine

53
Les tableaux
■ Le nombre d'éléments du tableau est mémorisé.
■ Java peut ainsi détecter à l'exécution le
dépassement d'indice et générer une
exception. Mot clé length
– Il est récupérable par [Link]
int tab = new int [20]; // tableau de
20 int int taille = [Link]; //taille
vaut 20
■ Comme en C/C++, les indices d’un tableau
commencent à ‘ 0 ’.
■ Donc un tableau de taille 100 aura ses indices qui
iront de 0 à 99.
54
 Les tableaux
■ Initialisation
tab[0]=1;
tab[1]=2; //etc.
noms[0] = new String( "Ahmed");
noms[1] = new String( "Ali");

■ Création et initialisation simultanées

String noms [ ] = {"Ahmed", " Ali"};

55
 Les tableaux
[Link] Mémoire
public class Tab1
{
public static void main (String args[])
{
int tab[ ] ; 0x258
0x0000
tab = new int[4];
tab[0]=5; 0
tab[1]=3; 0
tab[2]=7; 0
tab[3]=tab[0]+tab[1]; 0
}
}

56
 La classe String
■ Attention ce n’est pas un type de base. Il s'agit d'une
classe défini dans l’API Java (Dans le package
[Link])
String s="aaa"; // s contient la chaîne "aaa"
String s=new String("aaa"); // identique à la ligne précédente
■ La concaténation
– l‟opérateur + entre 2 String les concatène :
String str1 = "Bonjour ! ";
String str2 = null;
str2 = "Comment vas-tu ?";
String str3 = str1 + str2; / * Concaténation de chaînes : str3
contient " Bonjour ! Comment vas-tu ?"

57
Différences entre objets et types de base

Mémoire
3
int x=3,y=3;
x == y est vrai 3

0x768
0x852

String s1="Abc",s2="Abc"; Abc

s1 == s2 est faux... ....

Abc
....

58
La classe String
■ Longueur d’un objet String :
– méthode int length() : renvoie la longueur de la
chaîne String str1 = "bonjour";
int n = [Link](); // n vaut 7
■ Sous-chaînes
– méthode String substring(int debut, int fin)
– extraction de la sous-chaine depuis la position debut jusqu‟à
la position fin non-comprise.
String str2 = [Link](0,3); // str2 contient la valeur
"bon"
– le premier caractère d‟une chaîne occupe la position 0
– le deuxième paramètre de substring indique la position du
premier caractère que l ‟on ne souhaite pas copier

59
La classe String
■ Récupération d’un caractère dans une chaîne
– méthode char charAt(int pos) : renvoie le caractère situé à la
position pos dans la chaîne de caractère à laquelle on envoie
se message
String str1 = "bonjour";
char unJ = [Link](3); // unJ contient le caractère 'j'
■ Modification des objets String
– Les String sont inaltérables en Java : on ne peut
modifier individuellement les caractères d‟une chaîne.
– Par contre il est possible de modifier le contenu de la variable
contenant la chaîne (la variable ne référence plus la même
chaîne).
str1 = [Link](0,3) + " soir"; /* str1 contient
maintenant la chaîne "bonsoir" */
60
La classe String
■ Les chaînes de caractères sont des objets :
– pour tester si 2 chaînes sont égales il faut utiliser la méthode
boolean equals(String str) et non ==
– pour tester si 2 chaînes sont égales à la casse près il faut utiliser
la méthode boolean equalsIgnoreCase(String str)
String str1 = "BonJour";
String str2 = "bonjour"; String str3 =
"bonjour"; boolean a, b, c, d;
a = [Link]("BonJour"); //a contient la valeur true
b = (str2 = = str3); //b contient la valeur false
c = [Link](str2); //c contient la valeur true
d = "bonjour".equals(str2); //d contient la valeur true

61
La classe String
■ Quelques autres méthodes utiles
– boolean startsWith(String str) : pour tester si une chaine
de caractère commence par la chaine de caractère str
– boolean endsWith(String str) : pour tester si une chaîne
de caractère se termine par la chaine de caractère str

String str1 = "bonjour ";

boolean a = [Link]("bon"); //a vaut true
boolean b = [Link]("jour"); //b vaut true

62
La méthode static : [Link]
La méthode [Link] est une méthode statique
permettant de convertir tous les types de données enString.
/public static String valueOf( int i );
/public static String valueOf( byte b );
/public static String valueOf( short s );
/public static String valueOf( boolean b );
/public static String valueOf( long l );
/public static String valueOf( float f );
/public static String valueOf( double d );
/public static String valueOf( char c);
/public static String valueOf( char[] cTab);
/public static String valueOf( Object obj );

63
 Conversion d'une chaîne en un type primitif

■ Pour convertir une chaîne en un entier de type int,

on utilisera la méthode statique parseInt de la classe
enveloppe Integer, comme ceci

64
 Méthodes diverses

public String trim();

65
La classe Math
■ Les fonctions mathématiques les plus connues sont
regroupées dans la classe Math qui appartient au
package [Link]
– les fonctions trigonométriques
– les fonctions d‟arrondi, de valeur absolue, ...
– la racine carrée, la puissance, l‟exponentiel, le logarithme,
etc.
■ Ce sont des méthodes de classe (static)
double calcul = [Link] ([Link](5,2) + [Link](7,2));
double sqrt(double x) : racine carrée de x
double pow(double x, double y) : x puissance y

66
CLASSES ET OBJETS
 Modèle en cascade pour le
développement logiciel

Analyse
MERISE, UML, …
Conception

Implémentation Fortran, Pascal, C,

SmallTalk, C++, Java, …
Tests

Maintenance

68
 Langages Orientés-Objet
Un programme est composé de plusieurs
objets qui contiennent :
des données "internes"
des traitements manipulant ces
D
données internes ou d'autres
données T

Les données d'un objet sont appelés ses

D D
attributs et ses traitements sont ses
méthodes (ou opérations). T T

Exemples de langages orientés-objet : D

D
SmallTalk, C++, Java, Python, C#,
[Link], … T T
 L’approche objet
■ Idée de base de l‟Approche Orientée Objet (A.O.O.) repose sur
l’observation de la façon dont nous procédons dans notre vie de tous les
jours.
■ Qu’est-ce qu’un objet ?
– Le monde qui nous entoure est composé d'objets
– Ces objets ont tous deux caractéristiques
■ un état
■ un comportement

■ Objet = Attributs + méthodes

■ Ex. un objet "Télévision"
– ses états ={ allumé/éteint, chaîne courante, volume de son, marque },
– ses comportements ={ allumer, changer de chaîne, changer de volume de son,
éteindre }
83
 Classe
Des objets similaires peuvent être informatiquement décrits par
une même abstraction : une classe
même structure de données et méthodes de traitement

valeurs différentes pour chaque objet

Classe
Classe Employé Lecteur
Classe Livre Classe Journal
-titre, auteur -titre -nom, prénom, statut -nom, prénom

Germinal
Émile Zola
Le Monde Alice Dupont
Anne Durand
Directrice
Lectrice

Le seigneur des anneaux Arsène Deschamps

Michel Martin Lecteur
[Link]
Bibliothécaire
Le Matin
Contenu d'une classe
Une classe est composée de plusieurs membres dont chacun est soit :
un attribut : variable typée
une méthode (ou opération) : ensemble d'instructions de traitement

class CompteBancaire {
String
Attributs proprietaire;
double solde;

double getSolde() {
return solde;
Méthodes }

void credite(double val) {

solde = solde + val;
}
Contenu d'une classe
Véhicule Nom de la classe

Matricule : Chaîne
Marque : Chaîne
Puissance : Entier Description des
VitesseMax : Entier attributs ou
VitesseCourante : Entier données membres

CéerUnVehicule()
DétruireUnVéhicule() Description des
Démarrer() méthodes =
Accélerer(Taux: entier) traitements associés
Avancer()
Reculer()
73
Contenu d'une classe

74
Concept de classe
■ En informatique, la classe est un modèle décrivant les
caractéristiques communes et le comportement d‟un
ensemble d‟objets : la classe est un moule et l‟objet est
ce qui est moulé à partir de cette classe
■ Mais l'état de chaque objet est indépendant des autres
– Les objets sont des représentations dynamiques (appelées
instances) du
modèle défini au travers de la classe
– Une classe permet d‟instancier plusieurs objets
– Chaque objet est instance d‟une seule classe

75
 La classe : définition
■ Classe : description d’une famille d’objets ayant une
même structure et un même comportement. Elle est
caractérisée par :
– Un nom
– Une composante statique : des champs (ou attributs) nommés
ayant une valeur. Ils caractérisent l‟état des objets pendant
l‟exécution du programme
– Une composante dynamique : des méthodes représentant le
comportement des objets de cette classe. Elles manipulent les
champs des objets et caractérisent les actions pouvant être
effectuées par les objets.

76
La classe : représentation graphique

Personne Nom
Age : Integer
Taille : Double Champs
Poids : Double
Nom : String

parle()
mange() Méthodes
boit()
dort()

Une classe représentée avec la notation UML

(Unified Modeling Language)

77
 Syntaxe de définition d’une classe
Exemple : Une classe définissant un point
Class Point Nom de la Classe
{ float x; // abscisse du point
float y; // ordonnée du point Attributs
void initialiser(float X, float
Y){ x=X; Méthodes
y=Y;
}
void afficher(){
[Link]("x="+x+"\ty="+y);
}
}

78
L’instanciation
■ Instance
– représentant physique d'une classe
– obtenu par moulage du dictionnaire des variables et détenant les
valeurs de ces variables.
– Son comportement est défini par les méthodes de sa classe
– Par abus de langage « instance » = « objet »
■ Exemple :
– si nous avons une classe voiture, alors votre voiture est une
instance particulière de la classe voiture.
– Classe = concept, description
– Objet = représentant concret d‟une classe

79
 L’instanciation :
Exemple
■ Une classe peut être réutilisée pour instancier plusieurs
objets

80
 L’instanciation :
Exemple
■ Chaque Objet (p1, p2, p3) instance de la classe Point
possède sa propre valeur (son propre x et son propre y)

81
 Création d’objet
■ La création d‟un objet à partir d‟une classe s‟appelle :
instanciation
■ L‟objet créé s‟appel : instance de la classe.
■ Pour créer un Objet :
– Déclaration de l‟objet
– Instanciation et initialisation de l‟objet en utilisant l‟operateur
new suivi du constructeur de la classe.
■ Exemple :

Point p ; //Déclaration de l‟objet

p=new Point() ; //instanciation. (p est une instance de Point).
Point p2=new Point() ; // Déclaration et instanciation.

82
Les constructeurs
■ L'appel de new pour créer un nouvel objet
déclenche, dans l'ordre :
– L'allocation mémoire nécessaire au stockage de ce
nouvel objet et l'initialisation par défaut de ces attributs,
– L'initialisation explicite des attributs, s'il y a lieu,
– L'exécution d'un constructeur.
■ Un constructeur est une méthode d'initialisation.
public class Application
{ Le constructeur est ici
public static void main(String args[]) celui par défaut (pas
{ de constructeur défini
Personne pr= new Personne() dans la classe
[Link]("Hamidi") ; Personne)
} }

97
Les constructeurs
■ Lorsque l'initialisation explicite n'est pas possible
(par exemple lorsque la valeur initiale d'un attribut
est demandée dynamiquement à l'utilisateur), il est
possible de réaliser l'initialisation au travers d'un
constructeur.
■ Le constructeur est une méthode :
– de même nom que la classe,
– sans type de retour.
■ Toute classe possède au moins un constructeur. Si le
programmeur ne l'écrit pas, il en existe un par
défaut, sans paramètres, de code vide.

98
 Les constructeurs
[Link] Définition d’un
public class Personne Constructeur. Le
{ constructeur par défaut
public String nom; (Personne() )n’existe
public String prenom; plus.
public int age; Le code précédent
public Personne(String unNom, donnera une
erreur
String unPrenom, public class Application
int unAge) {
{ public static void main(String arg
nom=unNom; {
prenom=unPrenom Personne pr= new Personne();
; age = unAge; [Link](" Hamidi") ;
} }}
}
Va donner une erreur à la compilation

99
Les constructeurs
■ Pour une même classe, il peut y avoir plusieurs
constructeurs, de signatures différentes
(surcharge).
■ L'appel de ces constructeurs est réalisé avec le new
auquel on fait passer les paramètres.
– p1 = new Personne("Hamidi", "Ali", 56);
■ Déclenchement du "bon" constructeur
– Il se fait en fonction des paramètres passés lors de l'appel
(nombre et types).
■ Attention
– Si le programmeur crée un constructeur (même si c'est un
constructeur avec paramètres), le constructeur par défaut n'est plus
disponible. Attention aux erreurs de compilation !

100
Classe et objet en Java

Du modèle à … la classe Java et ... des instances

… de la classe à ... de cette classe

class Personne
{ Personne pr1, pr2;
String nom; pr1= new Personne ();
int age; pr2= new Personne ();
float salaire;
}
L’opérateur d’instanciation en Java est new
: MaClasse monObjet = new MaClasse();
En fait, new va réserver l’espace mémoire
nécessaire pour créer l’objet « monObjet » de la
classe
« MaClasse » 102
Affectation d’objets
:

88
Encapsulation des données
■ L'encapsulation permet de protéger les données d'un objet.
■ En effet, il n'est pas possible d'agir directement sur les données d'un
objet. Il est nécessaire de passer par ses méthodes (accesseurs et
mutateurs) qui jouent le rôle d'interface obligatoire.
■ L'appel de méthode est en fait l'envoi d'un message à l'objet.
■ Vu de l'extérieur, un objet se caractérise uniquement par les
spécifications de ses méthodes.
■ Le fonctionnement interne de l'objet est caché au monde extérieur.
■ Cette démarche vise à atteindre deux objectifs :
Augmenter la sécurité des programmes
Faciliter la maintenance de l'objet.

89
Encapsulation des données
■ En java, il est possible d‟agir sur la visibilité (accessibilité) des
membres (attributs et méthodes) d‟une classe vis-à-vis d‟autres
classes en précédant la déclaration da chaque attribut ou méthode
par l‟un des modificateurs (public, private, protected)
private : accessible que depuis l‟intérieur de la classe où il est
définie.
public : accessible depuis n‟importe quelle classe.
protected : accessible depuis sa classe, depuis les classes du
même package ou depuis les classe dérivées
■ L‟encapsulation consiste à protéger les attributs d‟un objet, pour
cela ces attributs doivent être déclarés private et on utilise des
méthodes public pour y accéder (ces méthodes sont appelées
accesseurs et mutateurs).

90
 Encapsulation
■ Exemples.
public class Personne class TestPersonne{
{ public static void main(String[] args){
public String nom; Personne p= new Personne ("Hamidi",
public String prenom; "Ali" , 20) ;
private int age;
public Personne(String N,
String P, int A) [Link]("Nom = " + [Link]);
{ //Affiche: Nom= Hamidi
nom=N;
prenom=P; [Link]("age= " + [Link]);
age = A; //erreur : car age est privé
}
}
}
}

91
Accesseurs :
■ Un accesseur (getter) est une méthode permettant
de récupérer le contenu d'un attribut protégée. Un
accesseur, pour accomplir sa fonction :
doit avoir comme type de retour le type
de la variable à renvoyer
ne doit pas nécessairement posséder d'arguments
(paramètres)
■ Une convention de nommage veut que l'on fasse
commencer le nom de l'accesseur par le préfixe
get.

92
 Accesseurs :
public class Personne{ class TestPersonne{
private String nom; public static void main(String[] args){
private int age;
Personne p= new Personne ("Ali", 20)
public Personne(String N, int A) {
nom=N; ;
age = A;
} [Link]("age=“ + [Link]);
//Accesseur de nom.
public String getNom( ) { //erreur : car age est privé
return (nom);
} //solution
//Accesseur de age. [Link]("age="
public int getAge( ) {
return (age);
+ [Link]());
} }
} }
93
Mutateurs :
■ Un mutateur (setter) est une méthode permettant de
modifier le contenu d‟un attribut protégée. Un mutateur,
pour accomplir sa fonction :
doit avoir comme paramètre la valeur à assigner à la
donnée membre. Le paramètre doit donc être du type
de la donnée membre
ne doit pas nécessairement renvoyer de valeur (il
possède dans sa plus simple expression le type void)
■ Une convention de nommage veut que l'on fasse
commencer le nom du mutateur par le préfix set.

94
 Mutateurs
public class class TestPersonne{
Personne{ private public static void main(String[]
String nom; private args){ Personne p= new Personne
int age;
("Ali", 20) ;
public Personne(String N, int A){
nom=N; [Link]("age=“ +
age = A; [Link]);
} //erreur : car age est privé
//accesseur pour récupérer age //solution
public int [Link]("age="+
getAge(){ [Link]()); [Link]=35 ; //erreur
return age; age est privé
//solution
}
//mutateur pour modifier age [Link](35) ;
public void setAge(int a){ }
age = a; } 11
1
L’opérateur this
■ Le mot-clé this désigne, dans une classe,
l'instance courante de la classe elle-même.
■ Exemple 1 :
■ si le constructeur a comme argument un nom de
variable identique à une variable de la classe et
qu‟on souhaite l'initialiser avec la variable passée
en paramètre, alors on écrit :

constructeur(int
maVar){
[Link]
r=maVar
}

96
 L’opérateur this
(Exemples)
public class Personne{
public class Point
{ private int x; private String nom; private
private int y; int age;
public Point() { public Personne(String nom, int age){
x = 0; [Link]=nom; [Link]
y = 0; = age;
} }
public Point(int x, int y) public int getAge(){
{ this.x = x; return age;
this.y = y; }
} public void setAge(int age){
} [Link] = age;
}
}
97
Surcharge d’une méthode
■ En Java, on peut surcharger une méthode, c‟est-
à-dire, ajouter une méthode qui a le même nom
mais pas la même signature qu‟une autre méthode
:

98
Surcharge d’une méthode (suite)
■ En Java, il est interdit de surcharger une
méthode en changeant le type de retour
■ Autrement dit, on ne peut différencier deux
méthodes par leur type de retour
■ Par exemple
il est interdit d'avoir ces deux méthodes
dans une classe
▪ int calculerSalaire(int)
▪ double calculerSalaire(int)

99
 Surcharge d’une méthode
(Exemple)
public class Test {
public Test() {
MaMethode ();
MaMethode (50);
}
public void MaMethode(int variable) {
[Link]("Le nombre que vous avez passé
en paramètre vaut : " + variable);
}
public void MaMethode() {
[Link]("Vous avez appelé la méthode
sans paramètre ");
}
}
100
Accès aux attributs et méthodes d’un objet
public class Application
{
public static void main(String args[])
{
Personne pr= new Personne()
[Link] = "Alami" ; // si l’attribut nom est
public [Link](25) ;
}
}
Remarque :
Contrairement aux variables, les attributs d'une classe, s'ils ne sont
pas initialisés, se voient affecter automatiquement une valeur par
défaut.
Cette valeur vaut : 0 pour les variables numériques, false pour les
booléens, et null pour les références.

117
Destruction d’objets
■ Java n‟a pas prévu la notion de destructeur telle
quelle en existe en C++.
■ La destruction des références d‟objets se fait
automatiquement grâce à un processus appelé
"ramasse miettes" (ou garbage collector) qui
s‟occupe de collecter les objets qui ne sont plus
référenciés.
■ La destruction des objets peut se faire manuellement
par la méthode [Link](). Cette méthode lance en
tâche de fond le ramasse-miettes.

102
Destruction d’objets
■ Il est possible au programmeur d'indiquer ce qu'il faut
faire juste avant de détruire un objet.
■ C'est le but de la méthode finalize() de l'objet.
■ Cette méthode est utile, par exemple, pour :
– fermer une base de données,
– fermer un fichier,
– couper une connexion réseau,
– etc.

103
 Destruction d’objets
■ Exemple.
public class TestMonMessage {
public static void main(String[] args) {
MonMessage Msg=new MonMessage();
[Link]("Bonjour tout le monde");
public class MonMessage {
Msg=null;
public void Afficher(String strMsg){
[Link]();
[Link](strMsg);
}
}
}
public void finalize( ) {
[Link]("c'est la fin de
l'objet");
}
}
Le programme affiche après l'exécution :
Bonjour tout le monde
c'est la fin de l'objet
104
 Variables de classe
■ Il peut s'avérer nécessaire de définir un attribut dont la
valeur soit partagée par toutes les instances d'une classe.
On parle de variable de classe.
■ Ces variables sont, de plus, stockées une seule fois, pour
toutes les instances d'une classe.
■ Donc tous les objets partagent la même valeur
■ Les attributs statiques sont déclarés par le modificateur :
static
■ Accès à l’attribut static :
– depuis une méthode de la classe comme pour tout autre attribut,
– via du nom de la classe, [Link]
– à l'aide instance de la classe. [Link]

105
Variables de Classe
Exemple1

class Toto { public class TesteToto {

int a; /* attribut public static void main (String[] arg)
d‟objet (non statique)*/ { Toto.b=10;
Toto obj1= new Toto ();
static int b; /*attribut de
obj1.a=20;
classe*/
Toto obj2= new Toto
} (); obj2.a=30;
obj2.b=15;//Pour tous les objets, b=15
[Link](Toto.b); // affiche
15 [Link](obj1.b); //
affiche 15 [Link](obj1.a);
//affiche 20 [Link](obj2.a);
// affiche 30
}
}

106
Variables de classe
Exemple2

class Personne { public class TestePersonne{

String public static void main( String args[])
nom ; int {
age ; int n= [Link];
public static int nb = 0; Personne p1, p2 ;
p1=new
public Personne Personne("Alami",20) ; p2=
(String nom , int age new Personne("Fatima",18) ;
) { [Link]([Link]) ;
[Link]=no //affiche 2 [Link]([Link]) ;
m; //affiche 2 [Link]([Link]) ;
[Link]=age //affiche 2
; nb++; }
} }
} 107
Méthodes de classe
■ Il peut être nécessaire de disposer d'une méthode qui
puisse être appelée sans instance de la classe. C'est une
méthode de classe.
■ On utilise là aussi le mot réservé static
■ Puisqu'une méthode de classe peut être appelée sans
même qu'il n'existe d'instance, une méthode de classe ne
peut pas accéder à des attributs non statiques. Elle ne
peut accéder qu'à ses propres variables et à des variables
de classe.

108
 Méthodes de classe
Exemple1

class UneClasse { class TesterUneClasse

public int x; { public static void main(String
public static int y ; args[]) {
[Link]éthode() ;
public static void maMéthode() { }
int v ; }
x = 5; // Erreur de
compilation y=7 ; //juste
v=10 ; //juste
}
}

La méthode maMéthode() est une méthode

Appel de maMéthode() via le
de classe (static) donc elle ne peut accéder à
nom de la classe sans même
un attribut non lui-même attribut de classe
qu'il n'existe d'instance (objet).
(non statique)
127
Méthodes de classe
■ Autres exemples de méthodes de classe
courantes : (Math, Integer et Float sont des
noms de classe)

– [Link](x);
– String chaine = [Link] (i); //convertir le nombre i
en chaine.

– int n = [Link](ch) ; //Convertir la chaine ch en

un int.
– float a= [Link](ch) ; // Convertir la chaine ch en
un float.
110
HÉRITAGE ET POLYMORPHISME

111
 L’héritage
■ L'héritage est un mécanisme qui permet à une classe
d'hériter de l'ensemble du comportement et des attributs
d'une autre classe.

■ Grâce à l'héritage, une classe peut disposer immédiatement

de toutes les fonctionnalités d'une classe existante. De ce
fait, pour créer la nouvelle classe, il suffit d'indiquer dans
quelle mesure elle diffère de la classe existante.

■ Une classe qui hérite d'une autre classe est appelée

sous-classe ou classe dérivée, et la classe qui offre son
héritage à une autre est appelée super-classe, ou classe de
base. 112
L’héritage (2) La classe A est la super-classe de B
La classe B est une sous-classe de A
La classe B est la super-classe de C, D et E
Les classes C, D et E sont des sous-classes
de B

113
L’héritage : exemple de graphe de l'héritage

L’héritage représente la relation: EST-UN

Exemple:
Un chat est un animal
Une moto est un véhicule
Une voiture de course est une voiture 132
 L’héritage : définition et principe
■ Héritage :
– mécanisme permettant le partage et la réutilisation de propriétés entre
les objets. La relation d‟héritage est une relation de généralisation /
spécialisation.
■ Hiérarchisation
– La classe dont on dérive est dite CLASSE DE BASE : Animal est la
classe de base (classe supérieure),
– Les classes obtenues par dérivation sont dites CLASSES
DÉRIVÉES :Chat, Chien et Oiseau sont des classes dérivées
(sous-classes).
■ Principe de l’héritage
– Besoins : éviter de dupliquer du code (attributs et méthodes) dans
différentes classes qui partagent des caractéristiques communes
■ facilite les modifications futures => elles n‟ont besoin d‟être faites
qu‟à un seul endroit
■ représentation explicite d‟une logique d‟héritage des concepts du
domaine (relation “est-un”) 133
 L’héritage (5) : représentation
graphique
Personne
Age : Integer
Taille : Double
Poids : Double
Nom : String Superclasse
parle()
mange()
boit()
dort()

Lien d’héritage

Conducteur
Sous-classe
conduire()
demarrer()

Représentation UML d’un héritage (simple)

116
 L’héritage en Java
■ Java implémente le mécanisme d'héritage simple qui permet
de "factoriser" de l'information grâce à une relation de
généralisation / spécialisation entre deux classes.
■ L'héritage multiple n'existe pas en Java.
– L‟implémentation d’interface permet de compenser cette
limitation
■ Pour le programmeur, il s'agit d'indiquer, dans la
sous-classe, le nom de la superclasse dont elle hérite.
■ Pour signifier qu'une classe fille hérite d'une classe mère,
on utilise le mot clé extends
class fille extends mere {
……

} 117
 L’héritage en Java
(Exemple)
class Personne
{
private String nom;
private Date date_naissance;
// ...
}
class Employe extends Personne
{
private float salaire;
// ...
}
class Etudiant extends Personne
{
private int numero_carte_etudiant;
// ...
} 136
 L’héritage en Java
■ En java, toutes les classes sont dérivées de la classe
Object.
– La classe Object est la classe de base de toutes les autres.
C'est la seule classe de Java qui ne possède pas de classe
mère.
– Tous les objets en Java, quelle que soit leur classe, sont du
type Object. Cela implique que tous les objets possèdent
déjà à leur naissance un certain nombre d'attributs et de
méthodes dérivées d'Object.
– Dans la déclaration d'une classe, si la clause extends n'est
pas présente, la surclasse immédiatement supérieure est
donc Object.
– Une méthode telle que toString() est définie dans Object, ce
qui explique que tout objet Java possède obligatoirement une
méthode toString().
– Il est possible (et même souhaitable) de redéfinir la méthode137
 L’héritage en Java
■ Constructeurs et héritage
– Si une classe A hérite d‟une classe B alors, la
construction d‟une instance de A commence toujours par
l‟appel d‟un constructeur de la super-classe B.
– Pour forcer l'appel d'un constructeur précis, on utilisera le
mot réservé super. Cet appel devra être la première
instruction du constructeur.
– Si aucun appel explicite à un des constructeurs de la classe
mère n‟est fait, le compilateur rajoute l‟instruction super()
à tous les constructeurs de la classe fille.

120
L’héritage en Java (4)
•public class Personne
•{
•private String nom, public class Employe extends
prenom; private int Personne
anNaissance; public {
Personne() private float saliare;
public Employe () {}
•{ public Employe (String nom,
String prenom, int annee, f
• nom=" "; prenom=" "; sal)
{
•} super(nom, prenom, annee);
salaire=sal;
•public Personne(String nom,
}
String prenom, int anNaissance)
}
•{
Appel explicite à ce constru
• [Link]=nom; avec le mot clé super
[Link]=prenom;
 Les membres protégés
■ Les sous-classes n'ont pas accès aux membres private de leur
classe mère.
public class Personne public class Employe extends
{ Personne
private String nom, prenom; {
private int anNaissance; public Employe () {}
public Personne(String nom,
String prenom, int anNaissance) public void affiche() {
{ [Link](" nom :" + nom);
[Link]=nom; }
[Link]=prenom; }
[Link]=anNaissance ;
} Erreur!
} nom est un attribut
private de Personne et n'est
donc pas accessible dans
40
la classe Employe 1
 Les membres protégés
■ Si on veut qu'un attribut ou une méthode soit encapsulé
pour l'extérieur mais qu'il soit accessible par les
sous-classes, il faut le déclarer protected à la place de
private.
public class Personne
{
protected String nom, prenom; public class Employe extends
public int anNaissance;
Personne
public Personne(String nom,
{
String prenom, int anNaissance)
public Employe () {}
{
[Link]=nom;
[Link]=prenom; public void affiche() {
[Link]=anNaissance; [Link](" nom :" + nom
} }
} }
 Accessibilité des membres (résumé)

Accessible Accessible à Accessible à

Modificateur Accessible à
à une classe du une classe
d'accès tous
la classe même fille
package
public Oui Oui Oui Oui

protected Oui Oui Oui Non

par défaut Oui Oui Non Non

private Oui Non Non Non

124
 Redéfinition de méthodes
■ Une sous-classe peut redéfinir des méthodes existant dans
une de ses superclasses (directe ou indirectes), à des fins de
spécialisation.
– La méthode redéfinie doit avoir la même signature.

Exemple
class Employe extends Personne class Cadre extends
{ Employe
private float salaire; {
public calculePrime( ) public calculePrime()
{ redéfinition {
// ... // ...
} }
} // ...
}

125