INTRODUCTION AU LANGAGE

JAVA
Dr. ADG
UADB
AMRT2 / 2019

1
 Plan du cours
• Généralités
• Syntaxe de base
• Structures de contrôle
• Programmation Orientée Objet
• L’héritage
• Classes abstraites et interface
• Packages
• Tableaux
• Chaines de caractères
• Gestion des Exceptions
2
 Bibliographie java (1/2)
• Le langage java, [Link], [Link], Thomson,1996.
• Programmer en Java, Claude Delannoy, 2000
• Le livre de Java premier langage: Avec 109 exercices
corrigés, Anne Tasso, 2012.
• Algorithmique et programmation en Java: Cours et
exercices corrigés, 2000.
• Le langage java-Programmer par l’exemple, [Link],
[Link], Technip, 2000.
• Algorithme et Programation objet en java, [Link],
Dunod, 2001.
3
 Bibliographie java (2/2)
• Initiation à l’algorithme objet, A. Cardon,
[Link], Eyrolles, 2001.
• Thinking in java, [Link], Printice Hall, 2000,
Disponible sous forme électronique à l’URL
[Link]
• Le poly de java, [Link], Polycopié, Université de la
Méditerranée, 2003.
• Site java de sun: [Link]
Ou
[Link]

4
Chapitre 1: GENERALITES

5
 C’est quoi java?
• Langage orienté objet (moderne) développé par sun Microsystems en
1990 (aujourd’hui racheté par Oracle).
• Excellente portabilité: une fois votre programme créé, il fonctionnera
automatiquement sous windows, Mac, Linux, etc.
Le compilateur java génère un pseudo-code (appelé bytecode) exécuté par
un interpréteur.
• On peut avoir de nombreuses programmes avec java:
– Des applications sous forme de fenêtre ou de console
– Des applets qui sont des programmes java incorporés à des pages web
– Des sockets pour la programmation réseau
– Des applications pour appareils mobiles, avec J2ME
– Et bien d’autres J2EE, JMF, J3D, etc.
• Grande richesse des APIs proposés: interfaces graphiques, bases de
données, réseau
• Syntaxe proche de C++
• Dernière version: Java 8

6
 C++/java
C++ : langage compilé
• La compilation du source permet d’obtenir des instructions
natives exécutables.
• Le code exécutable obtenu est très performant.
Java: langage interprété qui utilise une machine
virtuelle
• Machine virtuelle: simulation d’un ordinateur réel.
• La compilation d’un source java permet d’obtenir un code
exécutable, le bytecode, par la machine virtuelle java.
• La machine virtuelle java est capable de comprendre les
instructions contenues dans le bytecode et de les exécuter
effectivement dans l’environnement réel courant

7
 Java est portable

Interpréteur
Complilateur Java pour PC
Java pour PC

Pseudo-
Compilateur Interpréeur
Code java
Code java Java pour Java pour
Indépendant
source PowerPC PowerPC
De la platefome
.class

Compilateur
Java pour Interpréteur
Sun Solaris Java pour
Sun Solaris

8
 Kit de développement java(1)

3 choix sont possibles:

 Choix 1: le JDK de sun ([Link]
• reférence pour développer en java.
• Comporte tous les outils indispensables à la réalisation et
l’exécution d’un programme java.
• Totalement gratuit
• Ne comporte pas de véritable environnement de
développement.

9
 Kit de développement java(2)
 Choix 2: Freeware ou shareware
• Offrent une interface graphique au JDK
• Des outils supplémentaires (générateurs d’interface…)
• Exemple: Eclipse, NetBeans
 Choix 3: Environnement de développement
professionnel
• Très puissants
• Très chers…
• Exemples:
 JBuilder 2 de Inprise (anciennement Borland)
 Visual J++ de Microsoft

10
JRE (Java Runtime Environnment)

11
Chapitre 2: Syntaxe de base

12
 Premier programme java
// un premier programme
public class HelloWorld {
public static void main(String [ ] args) {
[Link]("Hello World !");
}
}

13
Structure du programme (1/2)

14
Structure du programme (2/2)

15
Contenu du programme

16
 Lire les entrées clavier

• import [Link];
• Afin de vous préparer à saisir des informations, veuillez
afficher un message à l’écran
1. Scanner sc = new Scanner([Link]);
[Link]("Veuillez saisir un mot :");
• Pour recupérer le mot
2. String str = [Link]();
3. [Link]("Vous avez saisi : " + str);
• Si c’est un nombre à saisir:
– nextInt () pour un entier
– nextFloat () pour un réel simple
– nextDouble () pour un réel à double précision
– nextByte () pour un byte 17
Compilation et Exécution d’un
programme

18
 Les commentaires
• /* commentaire sur une ou plusieurs lignes */
– Identiques à ceux existant dans le langage C
• // commentaire qui se tient sur une 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
 Identificateurs (1)
• 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
• exemples : MaClasse, UneJolieFenetre
21
 Identificateurs (2)

• 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

22
 Les Types Primitifs

Java dispose d’un certain nombre de types de base dits primitifs, permettant de
manipuler des entiers, des flottants, des caractères et des booléens.
Ce sont les seuls types du langage qui ne sont pas des classes.
Les types primitifs(au nombre de 8) se répartissent en quatre grandes catégories
selon la nature des informations qu’ils permettent de manipuler:
- nombres entiers,
- nombres flottants,
- caractères
- booléens

23
 Le type entier

Ils servent à représenter les nombres entiers relatifs, ils sont au nombre de
4.
BYTE (1 octet) SHORT (2 octets) INT (4 octets) LONG (8 octets)
byte 8 bits : −128 à 127
short 16 bits : −32768 à 32767
int 32 bits : −2147483648 à 2147483647
long 64 bits : −9223372036854775808 à
9223372036854775807

Les types élémentaires ont une taille identique quelque soit la

plate−forme d'exécution.

24
 Le type flottant

Ils permettent de représenter , de manière approchée, une partie des

nombres réels.
Java prévoit deux types de flottants correspondant chacun à des
emplacements mémoire de tailles différentes: float et double.

Double : 64 bits
Float : 32 bits
Exemple :

float pi = 3.141f; // nécessaire de suffixer par la lettre f sinon erreur de compilation

double v = 3d ; // suffixe d non nécessaire 3d = 3
float f = +1.1f , d = 1e10f; // déclaration de plusieurs variables de même type

25
 Le type caractère

CHAR ( 2 octets) et STRING

char : caractère isolé
-codage unicode sur 16 bits non signé
-expression littéral char entre apostrophes
‘+’, ‘a’ ,’\t’ , ‘\u???’
Une variable de type caractère se déclare:
char c1; char c1,c2 ; // c1 et c2 sont 2 variables
caractère
String : chaîne de caractères
-une expression littérale de type String
String s1 = "bonjour", s2 = new String( );
ATTENTION : String est une classe du paquetage [Link] .

26
 Le type booléen

Ce type sert à représenter une valeur logique du type vrai/faux

BOOLEAN
-Deux états: true / false
-Exemples:
boolean ok=false;
if (n<p) … //n<p est expression booléenne valant vrai ou
faux
boolean ordonne ; // déclaration d’une variable de type
booléenne
………………
ordonne =n<p; //ordonne reçoit la valeur de l’expression n <
p

27
 Initialisation des variables (1/2)

Exemple :

int nombre; // déclaration de la variable nombre

nombre = 100; //initialisation de la variable nombre
int nombre = 100; //déclaration et initialisation de la variable nombre

valeur = opérateur d’affectation

nom
type ( associatif de droite à gauche)
Remarque :
Une variable manipulée dans une méthode (variable locale) ou un bloc devra
toujours être initialisée avant toute utilisation.
La déclaration d’une variable réserve de la mémoire pour stocker sa valeur .
28
 Initialisation des variables (2/2)

En java, toute variable appartenant à un objet (définie comme étant un

attribut de l'objet) est initialisée avec une valeur par défaut en accord avec
son type au moment de la création.
Cette initialisation ne s'applique pas aux variables locales des méthodes de la
classe (cf :remarque précédente).
TYPE VALEUR PAR DÉFAUT
boolean false
byte, short, int, long 0

float, double 0.0

char u\000
classe null

29
 Utilisation des variables

package [Link] ;

public class UtilVariable

{ String chaine ; // variable de type (class ) String, valeur par défaut null
double solde ; // valeur par défaut 0.0 assignée à solde
public static void main(String [ ] args)
{
[Link](" valeur de solde =" +solde); new pour
} créer un objet
public void affiche( )
{ chaine = new String(" bonjour" ); // objet de type String initialisée
long nombre ; // erreur de compilation car nombre non initialisée
[Link](" valeur de nombre= "+nombre);
}}
30
 variables finales
(le mot clé final)

Java permet de déclarer que la valeur d’une variable ne doit pas être
modifiée pendant l’exécution du programme
package [Link] ; Une fois convenablement
public class VariableFinale initialisée une variable finale
{ final long NOMBRE ; ne peut pas voir sa valeur évoluée .
final double MAX = 100 ; // variable finale = constante
public static void main(String [ ] args)
{
[Link](" utilisation de variable constante" );
}
public void affiche( )
{ NOMBRE = 1000 ; // initialisation différée de la variable NOMBRE
[Link](" valeur de MAX= "+MAX);
}
31
}
 Les Opérateurs
(arithmétiques binaires)

package [Link] ;
public class Op_Arith_Binaire + - * / sont des
{ public static void main(String [ ] args) opérateurs arithmétiques
{ int a =100, b = 50 ; binaires qui portent sur deux
int addit = a + b ; opérandes de même type et
renvoient un résultat du même
soustr = a – b ; type que le type des opérandes ..
div = a / b;
addit = 150
multi = a*b; soustr = 50
[Link](" addit =" +addit ); div = 2
[Link](" soustr =" +soustr ); multi = 5000
[Link](" div =" +div );
[Link](" multi =" +multi );
32
}
 Les Opérateurs
(unaire et modulo)

package [Link] ;
public class Op_Unaire_et_Modulo Opérateur modulo:
{ public static void main(String [ ] args) fournit le reste de la
{ int a =100, b = 50 ; division de deux
opérandes.
int _modulo = 100 % 50 ;
[Link](" le reste de la division de " +a+" par" +b+" est" +_modulo );
float x = + 10.2f ;
-
double d= 50.2 ;
[Link] (" x et d sont des opérateurs unaires portant sur un seul opérande" );
}
} le reste de la division de 100 par 50 est 0
x et d sont des opérateurs unaires portant sur un seul opérande

33
 Exception sur la manipulation
des opérateurs(1/2)

package [Link] ;
/* test sur la division par zero de nombres entiers */
public class Test {
public static void main (String args[])
{
int valeur=10;
double résultat = valeur / 0;
[Link]("index = " + résultat);
}
} Exception in thread « main »
[Link]:/
by zéro at [Link] ( [Link]

34
 Exception sur la manipulation
des opérateurs(2/2)

Pour les entiers, la division par zéro (par / ou %) conduit à une erreur
d’exécution. Plus précisément, il y a déclenchement de ce que l’on
nomme une exception de type ArithmeticException.
Nous verrons plus tard comment traiter les excceptions.
Si nous ne le faisons pas, nous aboutissons à l’arrêt de l’exécution du
programme, avec un message de ce type:
Exception in thread « main » [Link]:/ by zéro at
[Link] ( [Link])
REMARQUE :
Pour les flottants, aucune opération ne conduit à un arrêt de
l’exécution (pas même une division par zéro ) ; seulement
on a une valeur non exploitable.
35
 Les opérateurs relationnels(1/2)

Les quatre premiers(

Opérateur signification <, <=, >, >=) sont de
< inférieur à même priorité. Les
<= inférieur ou égal à deux derniers(= = et
!=) possèdent
> supérieur à également la même
>= supérieur ou égal à priorité, mais celle-ci
== égal à est inférieur à celle
des précédents
!= différent de

Ces opérateurs sont moins prioritaires que les opérateurs arithmétiques.

Ils soumettent eux aussi leurs opérandes aux promotions numériques et
ajustement de type .
36
 Les opérateurs relationnels(2/2)

Exemple :
public class Oper_Relat {
public static void main(String args [])
{ int n = 10 ;
short s =10 ;
float x = 100;
double d= 200;
[Link]("Affichage 1 :"+(n = = s) );
[Link]("Affichage 2 :"+(d <= x) );
}
} Affichage 1 : true
Affichage 2 : false

37
 Les opérateurs logiques(1/3)

Java dispose d’opérateurs logiques classées par ordre de priorités

décroissantes (il n’existe pas deux opérateurs de même priorité).

Opérateur Signification
Le résultat
est ! négation
toujours un & et
booléen.
^ ou exclusif
| ou inclusif
&& et(avec cout-circuit)
|| Ou inclusif(avec court-circuit

38
 Les opérateurs logiques (2/3)

(a<b) && (c<d) ou (a<b) & (c<d)

prend la valeur true (vrai) si les deux expressions a<b et c<d sont toutes
les deux vraies (true), la valeur false (faux) dans le cas contraire.
(a<b) || (c<d) ou (a<b) | (c<d)
prend la valeur true si l’une au moins des deux conditions a<b et c<d
est vraie, la valeur false dans le cas contraire.
(a<b) ^ (c<d)
prend la valeur true si une et une seule des deux conditions a<b et c<d
est vraie, la valeur false dans le cas contraire.
!(a<b)
prend la valeur true si la condition a<b est fausse, la valeur false
dans le cas contraire. Cette expression possède la même valeur que
a>=b.

39
 Les opérateurs logiques (3/3)

Les opérateurs de cout-circuit && et || .

Ces deux opérateurs recèlent une propriété très

importante: leur second opérande (figurant à droite de
l’opérateur) n’est évalué qui si la connaissance de sa
valeur est indispensable pour décider si l’expression
correspondante est vraie ou fausse.

Exemple :
( 15 <10 ) && ( 10 > 4) //on évalue 15 <10 , le résultat
// est faux donc on n’ évalue pas
// 10 > 4

40
 Opérateurs
d’incrémentation et de décrémentation(1/2)

incrémentation
int i = 10 ; En fait en écrivant :
post incrémentation
int n= i++ ;
i++ ; // cette expression vaut 10 on a :
//mais i vaut 11 n= i ;
int j = 10 ; i = i+1 ;
Et en écrivant :
++j ; // cette expression vaut 11 int p= ++j ;
//et j vaut aussi 11 on a:
j = j+ 1 ;
pré incrémentation
p =j ;

Il existe un opérateur de décrémentation notée - -

41
 Opérateurs
d’incrémentation et de décrémentation(2/2)

Les opérateurs d’incrémentation et de décrémentation permettent d’alléger

l’écriture de certaines expressions et ils n’appliquent aucune conversion à leur
opérande.
package [Link] ;

public class TestIncrementation {

public static void main(String args [])
{ byte n = 10 ;
int s =n +1 ; // ici on ne peut pas écrire n = n+ 1

[Link]("Affichage 1 :" + ++n); // n reste byte

[Link]("Affichage 2 :"+ s); // n est converti en int
}
} Affichage 1 : 11
Affichage 2 : 11

42
 Opérateurs
d’affectation élargie

int i= 20 ;
i = i + 1 ; // i vaut 21
i += 1 ; //i vaut aussi 21 Leur rôle =
byte b = 2 ; condenser les
expressions.
Pas de conversion.
b *=2 ; // on évalue b * 2 en int
// mais le résultat est
//converti en byte

variable = variable opérateur expression  variable opérateur =

expression
Liste complète des opérateurs d’ affectation élargie :

+= -= *= /= |= ^= &= <<= >>= >>>=

43
 Opérateur
de cast

On a vu qu’il n’était pas possible d’écrire :

byte b = 10;
b = b + 1 ; //erreur de compilation
// incompatible type for =. Explicit cast
//needed to convert int to short.
Mais on peut faire ceci :
byte b = 10;
b =(byte) (b + 1) ; // OK   b +=1
On force le résultat dans le type byte
(double) 10/3 = (double)(10/3)
ATTENTION
44
 Opérateur
Conditionnel
?:

if(ciel == bleu)
temps ="beau"
else temps =ciel==bleu ?"beau" : " mauvais"
temps=" mauvais"

45
 Priorité des opérateurs (1/2)
(ordre de priorité décroissante)

les parenthèses ()
les opérateurs d'incrémentation ++ -- --

les opérateurs de multiplication, division, et * / %

modulo

les opérateurs d'addition et soustraction + -

les opérateurs de décalage << >>

les opérateurs de comparaison < > <= >=

46
 Priorité des opérateurs (2/2)
(ordre de priorité décroissante)

les opérateurs d'égalité == !=

l'opérateur OU exclusif ^
l'opérateur ET &
l'opérateur OU |

l'opérateur ET logique &&

l'opérateur OU logique ||
les opérateurs d'assignement = += -=

47
 Les mots réservés de Java

abstract default goto null synchronized

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

FIN DU MODULE
48
Chapitre 3: Les structures de contrôle

49
 Les structures de contrôles

• Les structures de contrôle classiques

existent en Java :
– if, else
– switch, case, default, break
– for
– while
– do, while

50
 Les structures de contrôles : if / else
• Instructions conditionnelles
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)
{ 1er bloc d’instructions}
else
{2ème bloc d’instruction}

51
 Les structures de contrôles : if / else

• Exemple de condition
if (age >= 65)
[Link]("Vous êtes une personne âgée.")

[Link]("L'année prochaine vous aurez "+age + 1, "

ans.")

52
 Les structures de contrôles : if / else if /
else

• Il est possible d'ajouter plusieurs conditions

successives, et un bloc par défaut (else = sinon)
if (condition1)
Instructions 1
else if (condition 2)
Instructions 2
else
instructions exécutées si condition1 et condition2 sont
fausses...

53
 Les structures de contrôles : if / else if /
else
• Exemple de condition
• Lire dans age
if (age == 0)
[Link]("Vous êtes un nouveau-né́.")
else if ( age < 18)
[Link]("Vous êtes un enfant.")
else if (age >= 65)
[Link]("Vous êtes une personne âgée.")
else
[Link]("Vous êtes un adulte.")
print("L'année prochaine vous aurez ", age + 1, " an

54
 Les structures de contrôles : if / else if /
else

• Les conditions peuvent être imbriquées

Lire dans age

if (age == 0)
[Link]("Vous êtes un nouveau-né.")
if poids > 10.0 :
[Link]("Je pense qu'il y a une erreur sur le
poids !")

55
 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

56
 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.

57
 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);
}
}

58
 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}}

59
 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);
}
}

60
 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’exclusion d’un long).
– 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
61
à la fin du switch
 Les structures de contrôles : switch

[Link]

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.
} 62
 La méthode main(1)

• Premier sous-programme exécuté au

lancement d’une application.
• Signature:
public static void main(String[] args){
…
}
• Le paramètre est un tableau de chaînes utilisé
pour les arguments transmis à partir de la
ligne de commande.
63
 La méthode main(2)
• Exemple avec arguments:
public class Somme{
public static void main(String[] args){
int x = [Link](args[0]);
int y = [Link](args[1]);
[Link](’’la somme de
‘’+x+’’ et ‘’+y+’’ est: ‘’+(x+y));
}
}
• Utilisation:
java Somme 12 14
 la somme de 12 et 14 est: 26
64
Concepts généraux de l’OO

65
La POO

66
 Notion de classe

•Une classe est la description d’une famille d’objets

ayant même structure et même comportement.

•Elle regroupe un ensemble d’attributs (données

représentant l’état de l’objet) et un ensemble de
méthodes (opérations applicables aux objets).

•Objet = instanciation d’une classe.

Fraction
+num : int
+den : int
afficher()
 Notion de classe (Exemple1)
• Une classe encapsule, c’est à dire regroupe
des propriétés et des comportements.
• Par exemple, la classe Humain définit des
propriétés (deux bras, deux jambes, etc.) et
des comportements (marcher, parler, voir,
etc.)

Classe Humain
68
 Notion de classe (Exemple1)
• Les comportements sont appelés méthodes et
les propriétés variables d’instance
• Notons que les propriétés des classes peuvent
être elles-mêmes des objets
• Par exemple la propriété bras de notre
exemple peut être un objet de type ‘Bras’
• Si nous prenons l’exemple d’une voiture, la
classe ‘Voiture’ sera l’ensemble des plans de la
voiture

69
 Notion de Classe (Exemple2)
La classe représente (modélise par abstraction) un ensemble d’objets
de même nature (partagent propriétés et méthodes)
Exemple : classe Employe
1) Diaw
2) camara Objets représentant des instances de classe
Une classe est décrite par son nom (Employe) par ses propriétés
(matricule, nom, qualification…) et ses opérations (embaucher()…)
Classe Employe
propriétés: matricule
Propriétés avec les types de données
nom correspondant et la portée (visibilité) à
… savoir: public privée, protégée…
Opérations: embaucher()
promotion()

70
 Notion d’objet
Un objet se définit par un triplet:
– Un identificateur (OID ou Object Identifier) qui permet de
le référencer de façon unique.
– Des données (attributs) caractérisant l’objet.
– Et des fonctions (méthodes) agissant sur ces données.
Elles caractérisent son comportement, i.e l’ensemble des
opérations que l’objet est à même de réaliser. Ces
opérations permettent de faire réagir l’objet aux
sollicitations extérieures (ou d’agir sur les autres objets.

Objet Propriétés
méthodes

71
 Notion d’objet (Exemple1)
• Un objet est une instance de classe, i.e un exemplaire
utilisable créé à partir de cette classe et en valorisant
certaines propriétés.
• Par exemple Balla ou Lissa sont des instances de la classe
Humain, i.e des humains ayant des propriétés spécifiques
(Balla est un humain aux yeux noirs et Lissa aux yeux marrons
• Notons que le concept de classe est abstrait: personne n’a
jamais vu d’humain dans la nature alors que le concept
d’objet est fondalementalement concrêt: il est concevable de
croiser des personnes physiques, i.e des instances d’Humain

72
Schematisation

73
 Notion d’objet (Exemple 2)

• Exemple:
Dans une société X, le cadre Camara qui est
ingénieur au service d’automatisme
embauché le 06/10/08 perçoit un salaire et
est enregistré sous le matricule 00745/C est
un objet concret (ou physique).
On peut afficher les informations concernant cet
objet.

74
 Notion d’objet (Exemple2)
L’ état de cet objet correspondant par exemple à sa date d’embauche à
l’instant t0
etat1 etat2
* matricule 00745/C ---
* nom Camara ---
* qualification ingénieur ingénieur chef
* poste de travail automatisme Product Division
* date d’embauche 06/10/08 ---
* salaire 300000 600000
L’objet peut avoir des transitions: passer d’un état à un autre: c’est le
comportement de l’objet qui se caractérise par les opérations qu’il peut
exécuter.
embaucher ()
promotion()
Comportement muter ()
salaire()
afficher()

75
 Notion de référence sur un objet

• Dans les programmes, un objet est une zone mémoire qui est
pointée par une ou plusieurs références
• Une fois l’objet instancié, il correspond en réalité à une zone
mémoire donnée. Cette zone mémoire, pour être utilisée doit
être référencée
• Par exemple, Balla est une référence sur l’objet de type
Humain correspondant et vaut l’adresse mémoire E515:FB80.
• Instancions l’objet Lissa: il ya une réservation d’une seconde
place mémoire référencée (pointée) par la référence Lissa
valant E515:FF90

76
 Notion de référence sur un objet

• Un objet peut posséder plusieurs références: par exemple, si

on fait Lissa=Balla, celà signifie qu’ils référencent le même
objet, la même zone mémoire
• Dans ce cas, l’objet Lissa est donc perdu, car il n’est plus
référencé
• Les références Lissa et Balla désignent maintenant le même
objet
• Dans la suite, nous designerons par abus de langage une
référence sur un objet par le terme ‘objet’. Par exemple,
‘’l’objet Lissa de type Humain’’ au lieu de ‘’la référence Lissa
sur l’objet correspondant de type Humain’’

77
 Définition d’une classe

Les champs x et y ne sont visibles

La méthode est accessible depuis
n’importe quel programme. qu’à l’intérieur de la classe et non à
l’extérieur : principe de
l’encapsulation des données. Les
public class Point données ne seront accessibles
{ que par l’intermédiaire de méthodes
private int x ; // champ x d’un objet Point prévues à cet effet.
private int y ; // champ y d’un objet Point
public void initialise ( int abs, int ord )
{ x = abs ;
y = ord ; Permet d’attribuer des valeurs initiales
} aux champs de l’objet.
Une méthode qui ne NB :on verra que c’est au constructeur
} // fin de la classe
fournit aucun résultat: d’effectuer ce travail.
 void

78
 Remarques

Une méthode peut être déclarée private : dans ce cas elle n’est visible qu’à
l’intérieur de la classe où elle est définie. Pour pouvoir l’utiliser dans un
autre programme, il faut nécessairement passer par une méthode publique
de sa classe ayant l’appelée.

Il est fortement déconseillé de déclarer des champs avec l’attribut public ,

cela nuit à l’encapsulation des données.

79
 Créer un objet = instancier une classe

int a = 10 ; // réservation de l’emplacement mémoire pour une variable de type int

float x ; // réservation de l’emplacement mémoire pour une variable de type float
Point a ; // cette déclaration ne réserve pas d’emplacement pour un objet de type
// Point mais simplement une référence à un objet de type Point.
La création d’un objet (on parle d’instanciation ) se fait avec l’opérateur new :
new Point ( ) ; // crée un emplacement pour un objet de type Point et
// fournit sa référence comme résultat
on pourra écrire :
a= new Point ( ) ; // crée un objet de type Point et on met sa reference
//dans // la variable a x
référence ?
? y objet
a
Point

80
 Manipulation d’objets

Une fois qu’une référence à un objet est convenablement initialisée,

on peut appliquer n’importe quelle méthode à l’objet correspondant .

[Link] ( 2,4 ) ; //appelle la méthode initialise du type Point en

// l’appliquant à l’objet de référence a, et en lui transmettant
// les arguments 2 et 4
Opérateur d’accès.

81
 Petit programme de test

class Point01
{ On a deux classes dans le
private int x ; // champ x d’un objet Point même fichier source. Seule
private int y ; // champ y d’un objet Point la classe contenant le
public void initialise ( int abs, int ord ) programme principal (main)
{ x = abs ; doit être déclarée avec
y = ord ; l’attribut public.
}
} // fin de la classe Point01
public class TestPoint01
{ public static void main( String args [ ] )
{ Point01 a = new Point01 ( ) ;
[Link]( 10,12 ) ; // le champ x aura la valeur 10 et y 12
}
} // fin de la classe TestPoint01

82
 Le constructeur (1/3)

En Java, la création d’objet se fait par allocation dynamique grâce à

l’opérateur
new qui appelle une méthode particulière : le constructeur.
Dans l’exemple précèdent, il n’y avait pas de constructeur mais plutôt c’était
la méthode initialise qui se chargeait d’initialiser correctement les champs
d’un objet de type Point. La démarche proposée suppose que l’utilisateur fera
appel de cette méthode au moment opportun pour initialiser correctement un
objet.
En fait un constructeur permet d’automatiser l’initialisation d’un objet.

Un constructeur est une méthode qui porte le même nom que le

nom de la classe et qui est sans valeur de retour.
Il peut disposer d’un nombre quelconque d’arguments.

83
 Le constructeur (2/3 )

class Point02
{
private int x ; // champ x d’un objet Point
private int y ; // champ y d’un objet Point
public Point02 ( int abs, int ord ) // un constructeur à deux
arguments
{ x = abs ;
y = ord ;
}
public void deplace (int dx, int dy )
{ x += dx ; y += dy ;
}
public void affiche( )
{ [Link]("Point de coordonnées" + x + " et " +y);
}
} //fin de la classe Point02
84
 Le constructeur ( 3/3)

public class TestPoint02

{ public static void main( String args [ ] )
{ Point02 a = new Point02 ( 10, 12 ) ; // le champ x aura la valeur 10 et
y 12 [Link]( ) ;
[Link]( 10,12 ) ;
[Link]( ) ; Point de coordonnées : 10 et 12
} // fin de la classe TestPoint02 Point de coordonnées : 20 et 24

85
 Quelques règles sur les constructeurs

Une classe peut disposer de plusieurs constructeurs: ils se différencieront par le nombre
et le type de leurs arguments.

Une classe peut ne pas disposer de constructeur; dans ce cas on peut instancier des
objets comme s’il existait un constructeur par défaut sans arguments et ne faisant rien.

Mais dès qu’une classe possède au moins un constructeur, ce constructeur par défaut
ne peut plus être utilisé, dans le dernier exemple on ne pouvait pas faire :
Point a = new Point ( ) ;// incorrect s’il y’a un constructeur
Une classe peut disposer d’un constructeur sans arguments qui est bien différent du
constructeur par défaut (appelé souvent pseudo-constructeur).

Un constructeur peut appeler un autre constructeur de la même classe (A VOIR).

Un constructeur peut être déclaré public ou privé.

86
 Construction d’un objet

La construction et l’initialisation des champs d’un objet se font en 3 étapes :

 l’initialisation par défaut de tous les champs à une valeur "nulle",
 l’initialisation explicite lors de la déclaration du champ,
 l’exécution des instructions du constructeur.

public class TestInit

{ private int nombre ;
private int diviseur = 12 ; nombre =24 nombre = 0 nombre = 0
public TestInit( ) { nombre = 24 ;} diviseur =12 diviseur =12 diviseur =0
public float diviser( )
{ return (float) nombre / diviseur ;
}
} Résultat : 2.0
87
 Valeur "nulle" suivant le type
du champ

Type du champ Valeur par défaut

booléen false
char caractère de code nul
entier(byte, short, int, long) 0
flottant( float, double) 0.f ou 0
objet null

Initialisation par défaut des champs d’un objet

88
 Champ déclaré avec l’attribut
final

public class ChampFinal

{ private final int NOMBRE ;// initialisation différée
private final float MAX ; // initialisation différée
private final int DIVISEUR = 12 ;// valeur fixée à la déclaration
public ChampFinal( int nbre)
{ NOMBRE = nbre ;// la valeur de NOMBRE dépendra de celle de nbre
MAX = 20 ; // la valeur de MAX est fixée à 20 une seule fois.
}
public float diviser( )
{ return (float) NOMBRE / DIVISEUR ;
}
ATTENTION: chaque objet possédera son propre champ NOMBRE,
} malgré que ce dernier est déclaré final.

89
 Affectation et comparaison d’objets

Point a ; 12
10
a = new Point (12,10 ) ;
a
11
Point b = new Point ( 11, 14 ); 14
b
affectation d’objet 12
a=b; a 10

Sera candidat au 11
ramasse-miettes b
14
s’il n’est plus référencé
Désormais a et b désignent le même objet.
 Référence nulle: le mot clé
null

class Point03
{
private int x ; // champ x d’un objet Point
private int y ; // champ y d’un objet Point
public Point03 ( int abs, int ord ) // un constructeur à deux arguments
{ x = abs ;
y = ord ;
} Les variables locales de type objet
public Point03 coincide (Point03 p ) doivent toujours être initialisées
{ Point03 t = null ; // t est locale donc nécessite de l’initialiser
if ((p.x = = this.x) && ( p.y = = this.y )) t = this;
else t = null;
return t ;
}
} //fin de la classe Point03

91
 Comparaison d’objets (1/2):
= = versus equals
public class Point03
{ private int x ; // champ x d’un objet Point
private int y ; // champ y d’un objet Point
public Point03 ( int abs, int ord ) // un constructeur à deux arguments
{ x = abs ;
y = ord ;
}
public static void main(String args [ ] )
{
Point03 a = new Point03 ( 1,1 );
Point03 b = new Point03 ( 1,1 );
[Link] ("avec = = : " + a == b);
[Link] ("avec equals :" + [Link] ( b ));
}
} //fin de la classe Point03 Résultat avec = = : false
avec equals : false
92
 Comparaison d’objets (2/2)

== teste s’il s’agit du même objet ( pas d’une copie ).

equals teste l’égalité de contenu de deux objets .

ATTENTION :
dans l’exemple précédent la méthode equals dont il s’agit est celle
de la classe Object (la super classe de toutes les classes en Java).
Souvent, vous serez emmené à redéfinir cette méthode.
Elle a pour en-tête:
public boolean equals (Object o )

L’opérateur != s’applique également à des références d’objet pour tester la différence.

93
 Méthodes de classe

Une méthode d’une classe ayant un rôle indépendant de toute instance de la classe
doit être déclarée avec le mot clé static et elle ne pourra être appliquée à aucun objet
de cette classe, contrairement aux méthodes d’instances.
L’appel de la méthode ne nécessitera que le nom que de la classe.

Une méthode statique ne peut pas agir sur des champs

ATTENTION : usuels, c’est-à-dire non statiques.

94
 Surdéfinition de méthodes

La surdéfinition de méthodes signifie qu’un même nom de méthode

peut être utilisé plusieurs fois dans une même classe .
Dans ce cas, le nombre et/ou le type des arguments doit
nécessairement changé.

On peut parler indifféremment de surdéfinition, surcharge ou

overloading (en Anglais).

95
 Exemple de surdéfinition de méthode

public class ExempleSurdefinition {

private int x ;
private int y ;
public ExempleSurdefinition (int abs, int ord ) { x=abs; y=ord; }
public void deplace (int dx, int dy) { x += dx ; y += dy ; }
public void deplace (int dx ) { x += dx ;
}
public void affiche(){ [Link](" Point de coordonnees :"+ x+ " "+y);}
public static void main(String[] args) {
ExempleSurdefinition ex = new ExempleSurdefinition(10,10);
[Link] ( 10 );// appel de deplace ( int )
[Link] ( );
[Link]( 10, 10 );// appel de deplace (int , int )
[Link]( ); Point de coordonnes : 20 10
} Point de coordonnes : 30 20
}
96
 ATTENTION :

Il peut y avoir des cas d’ambiguïté :

public void deplace (int dx, short dy)
{ x += dx ;
y += dy ;
}
public void deplace (short dy, int dx )
{ x += dx ;
}
avec : ExempleSurdefinition a = new
ExempleSurdefinition( 10, 12) ; short b;
l’appel [Link]( b ,b) causera une erreur.

97
 Surdéfinition de constructeurs

Les constructeurs peuvent être surdéfinis comme toute autre méthode.

public class Individu {
private String nom;
private String prenom; Attribut de type
private Compte c; objet. Il doit exister
/* constructeur à deux arguments*/ obligatoirement une
public Individu ( String lenom, String leprenom ) { classe Compte.
nom = lenom;
prenom = leprenom;
}
/* constructeur à trois arguments */
public Individu (String lenom, String leprenom, Compte cp) {
nom = lenom;
prenom = leprenom;
c = cp;
} }
 Transfert d’informations
avec les méthodes
En Java, la transmission d’informations se fait toujours par valeur.
La transmission, par exemple d’un argument à une méthode ou
d’une valeur de retour se fait toujours par valeur.

Cette transmission a des conséquences totalement

A RETENIR
différentes, selon que l’on manipule des types primitifs ou
bien des types objet ( c-à-d des références).

Transmission par valeur : la méthode reçoit une copie de la

RAPPEL valeur de l’argument effectif sur laquelle elle travaille. Pas de
possibilité d’agir sur la valeur de l’argument effectif.
Transmission par référence ( par adresse): la méthode reçoit
l’adresse de l’argument effectif sur laquelle elle travaille
directement. Ici, possibilité de modifier donc la valeur de
l’argument effectif.
 Illustration de la transmission de messages avec
les méthodes (1/2)

public class TransValeurTypePrimitif {

private double res;
public TransValeurTypePrimitif (double n) {
res = n; Argument muet.
2
}
public double add ( double p ) 10
{ p
return res += p; p contient
} 4 une copie
public static void main(String[] args) { 3 de la valeur
TransValeurTypePrimitif trans = new TransValeurTypePrimitif (12); de l’argument
effectif.
[Link] ( [Link] ( 10 ) );
10
}
1 Argument effectif.
}
 Illustration de la transmission de messages avec
les méthodes (2/2)

public class Point {

private int x;
private int y;
public Point (int abs, int ord) { Référence à un objet de type Point
x = abs; transmise en argument d’une
y = ord; Méthode.
}
public boolean coincide ( Point p)
p
{
return ( p.x == x && p.y == y); 12
} 12
public static void main (String [ ] args) {
Point a = new Point(10,12); b
Point b = new Point(12,12);
10
[Link]( [Link] ( b ) );
a 12
}}
101
 Autoréférence : this ( ½)

Dans un appel de la forme [Link]( b ), la méthode reçoit une information lui

permettant d’identifier l’objet ayant fait l’appel. Si l’information est transmise, la
méthode pourra agir sur les champs spécifiques de l’objet.
Cette transmission est gérée automatiquement par le compilateur.
Mais on peut vouloir agir sur l’objet globalement au lieu d’agir sur les champs.
Dans ce cas Java utilise le mot clé this. Dans l’exemple précédent, on peut
remplacer la méthode coincide par celle-ci:

public boolean coincide ( Point p)

{ // this reference ici l’objet courant ie celui ayant fait l’appel de coincide
return ( p.x == this.x && p.y == this.y);
}

Dans un appel [Link] (b) a désigne l’objet courant.

 Autoréférence : this ( 2/2)

L’utilisation de this est très pratique dans l’écriture des méthodes et surtout des
constructeurs.

// noms de champs et noms d’attributs // noms de champs et noms d’attributs

//différents //identiques
public Point ( int abs, int ord ) { public Point ( int x, int y ) {
x = abs; this.x = x;
y = ord; this.y = y;
} }

103
 Appel d’un constructeur dans un
autre constructeur. (1/2)
Un constructeur peut appeler un autre constructeur de la même classe en utilisant
le mot clé this. L’objectif majeur est la simplification du code et aussi pour des
problèmes de sécurité.

public class Individu { Cette classe peut être

private String nom; écrite de façon plus
private String prenom; sophistiquée comme
private Compte c; suit …
public Individu ( String lenom, String leprenom ) {
nom = lenom;
prenom = leprenom;
}
public Individu (String lenom, String leprenom, Compte c1) {
nom = lenom;
prenom = leprenom;
c = c1;
} }
 Appel d’un constructeur dans un
autre constructeur. (2/2)
public class Individu2 {
private String nom;
private String prenom;
private Compte c;
public Individu2 ( String nom, String prenom ) {
[Link] = nom;
[Link] = prenom;
}
public Individu2 (String nom, String prenom, Compte c) {
// appel du constructeur a deux arguments
this (nom, prenom);
this. c = c;
} }
L’appel this (…) doit nécessairement être la première
ATTENTION : Instruction du constructeur appelant.
 Objet membre

Objet membre = référence à un objet

public class Point { public class Cercle {

private int x; private double r; //rayon du cercle
private int y; private Point p;// objet membre
public Point (int abs, int ord) { public Cercle (double r, int x, int y) {
x = abs; this.r = r ;
y = ord; p = new Point (x, y);
} }
public void affiche ( ) public void affiche ( )
{ {[Link]("Cercle de rayon :" +r);
[Link](" Point :" +x " " +y); [Link](" et de centre:" );
} [Link]());
} }
}
Concepts de POO

107
 Concepts de POO
• Généralement, les données sont plus stables et
pérennes que les traitements qu’on leur applique.
• Donc, il est préférable de structurer un système par
rapport à ses données plutôt que par rapport à ses
fonctions.
→ Concept de POO: tout est dirigé par les données.
• Les concepts principaux de la POO:
 Encapsulation
 Héritage
 polymorphisme

108
 Concepts de POO: Encapsulation (1)
• Mécanisme consistant à empaqueter données et
traitements au sein d’une même structure en ne la
rendant accessible que par le biais des opérations
(interface) laissées visibles à cet usage.
• On empêche l’accès aux données par un autre
moyen que les services proposés.
• Cette structure qui encapsule les données et les
traitements s’appelle l’objet.
• L’encapsulation permet donc de garantir l’intégrité
des données contenues dans l’objet.

109
 Concepts de POO: Encapsulation (2)
• Intuition
On ne peut parler de l’état de l’employé Camara au sein
de la société X que s’il est embauché ou plus
précisément à partir du moment où on exécute
l’opération embaucher. Autrement les données ne sont
accessibles qu’au travers des méthodes des opérations.
On dit que les données sont cachées (encapsulées)
dans les opérations
L’encapsulation consiste à rattacher les données et les
méthodes à la classe.
On accède aux opérations par le nom de la classe et au
données par les opérations
classe méthode donnée

110
 Visibilité des champs et méthodes
• Le principe d’encapsulation permet d’introduire celui
de protection des attributs et méthodes.
• Les modifications de visibilité en java
– Public: accessible par toutes les classes. Hérité par les sous
classes.
– Private: accessible que par les seules méthodes de sa
classe. Non hérité.
– Protected: accessible par les classes du même package.
Hérité par les sous classes.
– Par défaut: accessible par les classes du même package.
Hérité par les sous classes que si elles se trouvent dans le
même package.
111
 L’héritage
• L’héritage permet de définir une nouvelle
classe à partir d’une (ou plusieurs) classe(s)
existante(s).
• Les classes sont souvent organisées en
hiérarchies; toutes les classes java héritent de
la classe [Link].
• Java n’autorise que l’héritage simple.
• L’héritage multiple est ‘’remplacé’’ par la
notion d’interface.

112
L’héritage simple: Exemple 1

Etudiant
+nom:int
numIns:int
setNumIns
getNumIns()
Afficher()

EtudiantBoursier
+bourse:double

113
 L’héritage simple:exemple
Public class EtudiantBoursier extends Etudiant{
public double bourse;
public EtudiantBoursier(String nom, double bourse){
super(nom); //appel au constructeur Etudiant(String)
[Link]=bourse;
}
public EtudiantBoursier(String nom){
this(nom,0); //appel au constructeur précédant
}
public void afficher(){ //redéfinition
[Link](‘’etudiant:’’+[Link]);
[Link](‘’bourse:’’+[Link]);
}
} 114
 Notion d’héritage (Exemple 2)
• A titre d’exemple: le cadre Camara et la secrétaire sont tous des employés.
• On peut considérer différentes catégories d’employés dans notre société X tel que
le cadre possède une propriété: indemnité de suggestion que ne possède pas la
secrétaire
• Inversement la secrétaire peut avoir un prime annuel spécial, mais ils ont tous des
propriétés communes
cadre
Employe

Matricule
Nom
…. Non
Embaucher() cadre

Superclasse sous classe

Chaque sous classe peut avoir des propriétés et des méthodes qui lui sont propres
tout en héritant des propriétés et des méthodes de la superclasse

115
 Notion d’héritage: Exemple 3

Supposons disposer d’une classe CompteBancaire:

On se propose de spécialiser la gestion

public class CompteBancaire { des comptes. On crée alors une classe
double solde ; CompteChèque et une autre classe
CompteBancaire (double solde ) CompteEpargne qui dérivent de la classe
{ [Link] = solde; CompteBancaire.
}
void deposer ( double montant)
{ solde +=montant;
}
void retirer (double montant)
{ if (solde >=montant ;
solde -=montant ;
}
} 116
 Notion d’héritage: Exemple 3

CompteBancaire
champs

solde
deposer ( ) méthodes
dérivation
retirer ()

CompteEpargne
CompteCheque taux
interets
decouvertAutorise
calculInterets( )
changeDecouvert ( )
crediterInterets( )
retirer ( )
changerTaux( )
117
 Notion d’héritage: Exemple 3

En Java, on utilise la
public class CompteCheque extends CompteBancaire { mention extends pour
signaler au compilateur
double decouvertAutorise; que la classe
CompteCheque (double solde, double decouvertAutorise) CompteCheque dérive
{ super (solde); de la classe
CompteBancaire.
[Link] = decouvertAutorise;
}
Ici, on rajoute un nouveau
void retirer (double montant) // methode redefinie champ decouvertAutorise.
{ if (solde + decouvertAutorise >=montant ; Et la méthode retirer est
solde -=montant ; redéfinie.
}
//………
}
118
 Notion d’héritage: Exemple 3

Ici, on rajoute un nouveau

champ taux.
public class CompteEpargne extends CompteBancaire {

double taux;
CompteEpargne (double solde, double taux)
{ super (solde);
this. taux = taux;
}
// pas de methode retirer

//………
}

119
 Accès aux membres {champs et méthodes}
de la classe de base.

Avec l’instruction :
CompteEpargne ce = new CompteEpargne ( 20000, 0.05) ;
On peut bien faire:
[Link] (10000) ;
malgré que la méthode retirer n’est pas définie dans la
classe CompteEpargne.

Un objet d’une classe dérivée accède aux membres publics de

sa classe de base, exactement comme s’ils étaient dans la classe dérivée
elle-même .

Une méthode d’une classe dérivée n’a pas accès aux

membres privés de sa classe de base .
120
 Construction des objets dérivés

La construction d’un objet dérivé est intégralement prise en compte par le

constructeur de la classe dérivée.

Par exemple, le constructeur de CompteCheque:

- initialise le champ decouvertAutorise (déjà membre de CompteCheque);
- appelle le constructeur de Compte pour initialiser le champ solde (hérité)
dans l’initialisation de champs d’un objet dérivé , il est fondamental et très
important de respecter une contrainte majeure:

Si un constructeur d’une classe dérivée appelle un constructeur d’une

classe de base, il doit obligatoirement s’agir de la première instruction
du constructeur et ce dernier est désigné par le mot clé super.
121
 Quelques remarques

Nous avons mentionné précédemment qu’il est possible d’appeler dans un

constructeur un autre constructeur de la même classe, en utilisant le mot clé

this comme nom de méthode . Comme celui effectué par super, cet appel
doit correspondre à la première instruction du constructeur .
Dans ces conditions, on voit bien qu’il n’est pas possible d’exploiter les deux
possibilités en même temps . Autrement dit, dans un constructeur d’une
Classe dérivée il n’est pas possible d’appeler en même temps un
constructeur de la même classe et un constructeur d’une classe de base.
L’appel par super ne concerne que le constructeur de la classe de base de niveau
immédiatement supérieur (vu qu’1 classe peut dériver d’une classe qui aussi dérive
d’1autre). 122
 Redéfinition de membres (1/4)

class CompteBancaire { class CompteCheque extends CompteBancaire {

double solde ;
// ……… double decouvertAutorise;
// methode redefinie
void retirer (double montant)
void retirer (double montant)
{ if (solde >=montant ;
solde -=montant ; { if (solde + decouvertAutorise >=montant ;
} solde -=montant ;
void imprimeHistorique( ) }
{ [Link] (" solde =" void imprimeHistoriqueCheque( )
+solde ); { [Link] (" solde =" +solde + " " +
} "decouvertAutorise=" +decouvertAutorise);
}
}
123
 Redéfinition de membres (2/4)

Avec :
CompteBancaire cb; CompteCheque cc;
l’appel : [Link] ( 20000);
appelle la méthode retirer de CompteBancaire.
l’appel : [Link] ( 20000);
appelle la méthode retirer de CompteCheque.
On se base tout simplement sur le type de l’objet pour déterminer la classe
de la méthode appelée.
Pour bien voir l’intérêt de la redéfinition des méthodes, examinons la méthode
imprimeHistorique de la classe CompteBancaire qui permet d’afficher le solde pour
un compte et la méthode imprimeHistoriqueCheque de la classe CompteCheque qui
affiche non seulement le solde (qui est un membre hérité) mais aussi le
decouvertAutorise.
Dans cette dernière, il y a une information qui est déjà prise en compte dans la
méthode imprimeHistorique. La situation précédente peut être améliorée de
cette façon: 124
 Redéfinition de membres (3/4)

class CompteBancaire { class CompteCheque extends CompteBancaire {

double solde ;
// ……… double decouvertAutorise;
// methode redefinie
void retirer (double montant)
void retirer (double montant)
{ if (solde >=montant ; { if (solde + decouvertAutorise >=montant ;
solde -=montant ; solde -=montant ;
} }
void imprimeHistorique( ) void imprimeHistoriqueCheque( )
{ [Link] (" solde =" {
+solde ); imprimeHistorique( );
} [Link] (" et le decouvertAutorise ="
+decouvertAutorise);
}
} 125
 Redéfinition de membres (4/4)

class CompteBancaire { class CompteCheque extends CompteBancaire {

double solde ;
// ……… double decouvertAutorise;
// methode redefinie
void retirer (double montant)
void retirer (double montant)
{ if (solde >=montant ; { if (solde + decouvertAutorise >=montant ;
solde -=montant ; solde -=montant ;
} }
void imprimeHistorique( ) void imprimeHistorique( )
{
{ [Link] (" solde =" [Link]( );
+solde ); [Link] (" et le decouvertAutorise ="
} +decouvertAutorise);
}
super obligatoire. 126
}
 Redéfinition et dérivation successive

A* f est redéfinie
ici.

f est redéfinie C*
B
ici.

D * E F

L’appel de f conduira, pour chaque classe, à l’appel de la méthode indiquée en regard :

class A : méthode f de A class D: méthode f de D
class B: méthode f de A class E: méthode f de A
class C: méthode f de C class F: méthode f de C
127
 Surdéfinition et héritage

Calcul c; CalculXXX cx;

int n; float p;
class Calcul {
public double division ( int a) // 1 [Link] (n); // appel de 1
{ // instructions
} [Link] (p); // erreur de compilation
}
[Link] (n); // appel de 1
class CalculXXX extends Calcul {
public float division ( float a) // 2 [Link] (p); // appel de 2

{ // instructions La recherche d’une méthode acceptable ne se

} fait qu’en remontant la hiérarchie d’héritage,
} jamais en la descendant. C’est pourquoi l’appel
[Link] (p); ne peut être satisfait.
 Contraintes sur la redéfinition (1/2)

En cas de redéfinition, Java impose seulement l’identité des signatures

mais aussi du type de la valeur de retour

Valeurs de retour identiques Signatures identiques

class CompteBancaire { class CompteCheque extends CompteBancaire {

double solde ; double decouvertAutorise;
// ……… // methode redefinie
void retirer (double montant)
void retirer (double montant)
{ if (solde >=montant ; { if (solde + decouvertAutorise >=montant ;
solde -=montant ; solde -=montant ;
}} }
} 129
 Contraintes sur la redéfinition (2/2)

La redéfinition d’une méthode ne doit pas diminuer les droits d’accès

à cette méthode.
Par contre, elle peut les augmenter.

class A class A
{ public void f ( int n){……} { private void f ( int n){……}
} }
class B extends A class B extends A
{// impossible de mettre private {// augmente les droits d acces:
private void f ( int n) {….} possible
} public void f ( int n) {….}
}
 Duplication de champs

class A
{ public int resultat;
class B extends A
{ /* le champ resultat est duplique */
// instructions
public int resultat ;
}
float calcul( int n)
{ return resultat + [Link] +n;
}
}

On utilise le mot clé super

pour accéder à un champ de la super classe
131
 Le Polymorphisme

Surclassement
La réutilisation de code est un aspect important de l’héritage, mais ce n’est peut
être pas le plus important.
Un autre aspect fondamental est la relation qui relie une classe à sa super
classe.

Une classe B qui hérite d’une classe A peut être vue comme un sous-type (sous -
ensemble) du type défini par la classe A.
CompteBancaire
Un CompteCheque est un CompteBancaire

L’ensemble des compte chèque est inclus

CompteCheque dans l’ensemble des compte bancaires
132
 Surclassement
Tout objet instance de la classe B peut être aussi vu comme une instance de la classe A.

Cette relation est directement supportée par le langage JAVA.

« à une référence déclarée de type A, il est possible d’affecter une valeur qui
est une référence vers un objet de type B (surclassement ou upcasting) »

CompteBancaire CompteBancaire cb;

cb = new CompteCheque( 100000, 50000 );
« plus généralement, à une référence d’un type donné,
CompteCheque il est possible d’affecter une valeur qui correspond à une
référence vers un objet dont le type effectif est n’importe
quelle sous-classe directe ou indirecte du type de la
référence ».
 Surclassement

Lorsqu’un objet est « sur-classé » il est vu comme un objet du type de la référence

utilisée pour le désigner.
« ses fonctionnalités sont alors restreintes à celles proposées par la classe du type
de la référence ».
CompteCheque cc = new CompteCheque(100,50);
CompteBancaire CompteBancaire cb;
solde cb = cc; // surclassement
deposer ( ) [Link] (50);
retirer () [Link]( 25);

[Link] (500);
CompteCheque [Link] ( 250);
decouvertAutorise [Link] ( );
changeDecouvert ( )
retirer ( ) [Link]( );
134
 Liaison dynamique

Résolution des messages

« Que va donner [Link] ( 50) ? »

CompteBancaire
CompteBancaire cb = new
void retirer (double montant)
CompteCheque (500,100);
{ if (solde >=montant )
solde -=montant ;
? }
[Link] ( 50)
? CompteCheque
void retirer (double montant)
{if (solde + decouvertAutorise >=montant )
solde -=montant ;

} 135
 Liaison dynamique

Résolution des messages

CompteBancaire
CompteBancaire cb = new
void retirer (double montant)
CompteCheque (500,100);
{ if (solde >=montant ;
solde -=montant ;
? }
[Link] ( 50)
CompteCheque
void retirer (double montant)
{if (solde + decouvertAutorise >=montant ;
solde -=montant ;

} 136