Java programmation OO, héritage et polymorphisme

JAVA
Programmation Orientée Objet

2
Plan du cours
 Concepts de l’OO
 Les variables: Déclaration et portée
 Les méthodes: Déclaration, interface et surcharge
 La création d’objets: Constructeurs et mot-clé « new »
 L’encapsulation: « public », « private » et « protected »
 Utilisation de l’héritage: « this » et « super »
 Polymorphisme
 Exceptions

3
Objectifs du cours
 Décrire les éléments-clé de la plate-forme Java
 Compiler et exécuter une application Java
 Décrire la syntaxe du langage
 Comprendre le paradigme Orienté Objet
 Utiliser Java pour mettre en œuvre le paradigme OO

4
Références Web
 The Java Tutorial from Sun
http://java.sun.com/docs/books/tutorial/
 The Java Developer Connection
http://developer.java.sun.com/developer/index.html

6
Survol du chapitre
 Qu’est-ce que Java ?
 Java comme langage de programmation
 La plateforme Java
 La Java Virtual Machine
 Les interfaces de programmation d’application (API)
 Déploiement d’un programme
 Quelques notions historiques

7
Qu’est-ce que Java ?
 Java est un langage de programmation
 Voir le « white paper » de J.Gosling
 Un programme Java est compilé et interprété
 Java est une plateforme
 La plateforme Java, uniquement software, est exécutée sur la
plateforme du système d’exploitation
 La « Java Platform » est constituée de :
 La « Java Virtual Machine » (JVM)
 Des interfaces de programmation d’application (Java API)

8
Java comme langage de programmation
Java est un langage de programmation particulier qui
possède des caractéristiques avantageuses:
 Simplicité et productivité:
 Intégration complète de l’OO
 Gestion mémoire (« Garbage collector »)
 Robustesse, fiabilité et sécurité
 Indépendance par rapport aux plateformes
 Ouverture:
 Support intégré d’Internet
 Connexion intégrée aux bases de données (JDBC)
 Support des caractères internationaux
 Distribution et aspects dynamiques
 Performance

9
Java comme langage de programmation
Neutre architecturalement
 Il existe une grande diversité de
systèmes d’exploitation
 Le compilateur Java génère un
bytecode, c’est à dire un format
intermédiaire, neutre
architecturalement, conçu pour
faire transiter efficacement le
code vers des hardware
différents et/ou plateformes
différentes
 Le bytecode ne peut-être
interprété que par le
processeur de la JVM
MyProgram.java
MyProgram.class
Mac
JVM
Java Compiler
= bytecode
Windows
JVM
Unix
JVM

10
Java comme Plateforme
 Plateforme = environnement hardware ou software sur
lequel le programme est exécuté.
 La Java « Platform » se compose de:
 la Java Virtual Machine (Java VM)
 la Java Application Programming Interface (Java API)

11
Java comme Plateforme
Java Application Programming Interface (API)
 L’API Java est structuré en libraires (packages). Les packages
comprennent des ensembles fonctionnels de composants (classes)..
 Le noyau (core) de l’API Java (incluse dans toute implémentation
complète de la plateforme Java) comprend notamment :
 Essentials (data types, objects, string, array, vector, I/O,date,…)
 Applet
 Abstract Windowing Toolkit (AWT)
 Basic Networking (URL, Socket –TCP or UDP-,IP)
 Evolved Networking (Remote Method Invocation)
 Internationalization
 Security
 …..

12
Déploiement d’un programme (1/2)
Paradigme classique de la compilation
MyProgram.c
Compiler
MyProgram.o
010110…
Génère du code natif directement
exécutable, mais spécifique à
chaque environnement
Exécuté une seule fois
Mais différent pour
chaque environnement

13
Déploiement d’un programme (2/2)
Changement de la vision traditionnelle de la compilation
 Chaque programme est compilé et interprété
 « Write once run everywhere »
MyProgram.java
Compiler
MyProgram.class
Interpreter
010110…
Traduit le programme en un code intermédiaire
Appelé bytecode – indépendant de la machine
Lit le bytecode et exécute sur la machine
Exécuté une seule fois
Chaque fois que le
programme est exécuté

II. Première application en Java

15
Deux façons d’écrire des programmes Java:
 En écrivant le code dans un simple éditeur de texte
 Compilation et exécution du code en ligne de commande DOS
 En utilisant un environnement de développement (IDE)
 Netbeans (http://www.netbeans.com)
 Borland JBuilder (http://www.borland.com/jbuilder)
 IBM WebSphere Studio (http://www.ibm.com/software/awdtools)
 Sun ONE Studio (http://wwws.sun.com/software/sundev)
 Microsoft .Net Studio (http://msdn.microsoft.com/vstudio)
 … Crimson Editor !!!!
Comment développer une application?

16
Une première application
Application HelloWorld
 Créer un fichier texte : HelloWorld.java
 Règle de bonne pratique : 1 classe par fichier et 1 fichier par classe
La première ligne du programme doit être la
déclaration de la classe
Tout programme doit contenir une méthode
main qui porte la signature ci-contre
Écrire à l’écran “Hello the World”
Fermer les accolades
public class HelloWorld
{
public static void main (String[]args)
{
System.out.println("Hello the World");
}
}
 Compiler le programme : javac HelloWorld.java
 Le compilateur génère le bytecode dans le fichier : HelloWorld.class
 Exécuter l’application : java HelloWorld
 « Hello the World » s’affiche à l’écran
EX 2.1

18
Survol du chapitre
 Conventions d’écriture
 Commentaires dans le code source
 Identificateurs
 Mots-clé
 Types primitifs et types de références
 La classe String
 Arithmétique et opérateurs
 Instructions de contrôle
 If, then, else
 For
 While
 Do… While
 Break et Continue
 Les tableaux (« Array »)

19
Conventions d’écriture
Classes
class BankAccount
class RacingBike
Interfaces
interface Account
Méthodes
deposit()
getName()
Packages
package coursTechnofutur3.bank ;
Variables
int accountNumber
Constantes
MAXIMUM_SIZE

20
Commentaires dans le code source
Trois façons d’inclure des commentaires :
 Tout texte entre « // » et la fin de la ligne
// Commentaires sur une seule ligne
 Tout texte entre « /* » et « */ »
/* Commentaires
sur un nombre important voire très important
de lignes */
 Les textes entre « /** » et « */ » sont utilisés pour créer des commentaires que
l’exécutable JAVADOC pourra traiter afin de produire une documentation (cf.
documentation de l’API Java)
/** Commentaires destinés
à la documentation */

21
Identificateurs
 Un identificateur (identifier) permet de désigner une classe, une
méthode, une variable …
 On ne peut utiliser ce que l’on veut :
 Interdiction d’utiliser les mots-clés
 Commencent par :
 Une lettre
 Un « $ »
 Un « _ » (underscore)
 Ne commencent pas par :
 Un chiffre
 Un signe de ponctuation autre que « $ » ou « _ »

22
Mots-clé
abstract double int strictfp **
boolean else interface super
break extends long switch
byte final native synchronized
case finally new this
catch float package throw
char for private throws
class goto * protected transient
const * if public try
continue implements return void
default import short volatile
do instanceof static while
* Indique un mot clé qui est peu utilisé
** A partir de la plate-forme Java2

23
Types primitifs et types de référence
 Java est un langage fortement typé
 Le type de données précise
 les valeurs que la variable peut contenir
 les opérations que l’on peut réaliser dessus
 Deux types de données:
 Donnée primitive: contient physiquement la valeur
(caractère, nombre, booléen)
 Référence: contient l’adresse mémoire où l’information relative à l’objet,
l’interface, etc. est réellement stockée
Adresse
Référence:

24
Types de données primitifs (1/4)
byte 8bits -128 to 127
short 16bits -32768 to 32767
int 32bits -2^31 to 2^31-1
long 64 bits -2^63 to 2^63-1
Integral
float 32bits 1.4E-45 3.4E 38
double 64bits 4.9E -324 1.8E308
Floating
char 16bits 0 to 65535
Te xtual
one bit : true or false
Logical
Prim itive Data Types

25
 Explication:
 byte : codé sur 8 bits  28
valeurs  (–27
) to (27
–1) = -128 à 127
 int : codé sur 32 bits  232
valeurs  (–231
) to (231
–1)
 Déclaration et initialisation :
 int x=12;
 short x= 32; (short x=33000; // Hors limite)
 long x= 200L; // Nombre accolé à un L
 byte x=012; // Nombre commençant avec un 0
 double x=23.2323;
 float x= 23.233F; // Nombre accolé à un F
 char c=‘a’; char c=‘u0061’; char c=(char)97;
 boolean b=true;

26
Déclaration, Initialisation et Assignation des types primitifs
int t; Déclaration d’un entier t (t est l’identificateur)
int u = 3; Déclaration et initialisation d’un entier
t=7; Initialisation de t à la valeur 7
u=t; Assignation (affectation) de la valeur de t à u
m=9; Erreur déclaration préalable nécessaire
char c; Déclaration
c=‘a’; Initialisation

27
Exemple:
int a = 5;
int b = 8;
a=b;
Déclaration et initialisation de 2 entiers: a et b
Affectation de la valeur de b à a
Désormais, il existe deux variables en mémoire qui ont la
même valeur
a=8 b=8

28
Types de référence
 Tous les types hormis les types primitifs
 « Pointeur implicite » sur un objet
Adresse
Référence:

29
La classe String
 String n’est pas un type primitif, c’est une classe
 Déclaration de deux String:
String s1, s2;
 Initialisation :
s1 = "Hello";
s2 = "le monde";
 Déclaration et initialisation :
String s3 = "Hello";
 Concaténation :
String s4 = s1 + " " + s2;

30
Arithmétique et opérateurs
Arithmétique élémentaire
 Quelle est la valeur de : 5+3*4+(12/4+1)
 Règles de précédences sur les opérateurs:
Niveau Symbole Signification
1 () Parenthèse
2
*
/
%
Produit
Division
Modulo
3
+
-
Addition ou concaténation
Soustraction

31
Opérateurs de comparaison
 Pour comparer deux valeurs:
 Opérateurs logiques:
Opérateur Exemple Renvoie TRUE si
>
>=
v1 > v2
v1 >= v2
v1 plus grand que v2
Plus grand ou égal
<
<=
v1 < v2
v1 <= v2
Plus petit que
Plus petit ou égal à
==
!=
v1 == v2
v1 != v2
égal
différent
Opérateur Usage Renvoie TRUE si
&&
&
expr1 && expr2
expr1 & expr2
expr1 et expr2 sont vraies
Idem mais évalue toujours les 2 expressions
||
|
expr1 || expr2
expr1 | expr2
Expr1 ou expr2, une ou les deux sont vraies
idem mais évalue toujours les 2 expressions
! ! expr1 expr1 est fausse
!= expr1 != expr2 si expr1 est différent de expr2

32
Opérateurs d’assignation (d’affectation)
 L’opérateur de base est ‘=‘
 Il existe des opérateurs d’assignation qui réalisent à la fois
 une opération arithmétique, logique, ou bit à bit
 et l’assignation proprement dite
Opérateur Exemple Équivalent à
+= expr1 += expr2 expr1 = expr1 + expr2
-= expr1 -= expr2 expr1 = expr1 – expr2
*= expr1 *= expr2 expr1 = expr1 * expr2
/= expr1 /= expr2 expr1 = expr1 / expr2
%= expr1 %= expr2 expr1 = expr1 % expr2

33
Instructions et structures de contrôle
Déclarations, instructions, blocs
 Une instruction
 Réalise un traitement particulier:
 Renvoie éventuellement le résultat du calcul
 Est comparable à une phrase du langage naturel
 Constitue l’unité d’exécution
 Est toujours suivie de « ; »
 Instruction d’affectation (d’assignation), instruction de déclaration …
 Un bloc
 Est une suite d’instructions entre accolades « { » et « } »
 Délimite la portée des variables qui y sont déclarées
 Une déclaration
 Constitue la signature d’un élément (classe, variable ou méthode)
 Annonce la définition de cet élément
 Est (normalement) toujours suivie d’un bloc d’instructions

34
Structures de contrôle
 Les structures de contrôles permettent d’arrêter l’exécution linéaire
des instructions (de bas en haut et de gauche à droite)
 Elles permettent d’exécuter conditionnellement une instruction, ou de
réaliser une boucle
Type d’instruction Mots clés utilisés
Décision if() else – switch() case
Boucle for( ; ; ) – while () – do while()
Traitement d’exceptions try catch finally – throw
Branchement label : -- break – continue -- return

35
IF – THEN – ELSE
if (expression)
{
//instructions
}
if (expression)
{
//instructions
}
else
{
//instructions dans les autres cas
}

36
SWITCH – CASE
switch (number)
{
case 1 : instructions;
case 2 : instructions; break;
default : instructions;
}

37
FOR
for (initialisation; condition; mise à jour de valeurs){
// instructions
}
 Initialisation: à exécuter lorsque le programme rentre pour la première
fois dans la boucle
 Condition : à remplir pour recommencer le bloc d’instructions
 Mise à jour: instruction exécutée chaque fois que la boucle est terminée
Exemples:
for (int i=0 ; i<10 ; i++) {
System.out.println("The value of i is : " + i);
}

38
WHILE – DO WHILE
while (test logique) {
//instructions
}
Si le code de la boucle doit être exécuté la première fois de toute façon:
do {
// code to perform
} while (logical_test)
Boucle infinie:
while (true) {
//instructions
}

39
 BREAK / CONTINUE
 BREAK: achève immédiatement la boucle
 CONTINUE: ignore le reste des instructions et recommence au début
de la boucle
for (int i=0; i<10 ;i++){
if (i==5) continue; // Si i=5, on recommence au début
if (i==7) break; /* Si i=7, on sort de la boucle et
les instructions suivantes sont
exécutées */
System.out.println("The value of i is : " + i);
}

40
Les tableaux (“Array”) (1/2)
 Un tableau est utilisé pour stocker une collection de variables de
même type
 On peut créer des tableaux de types primitifs ou de types de
références
(cf. argument de la fonction main : String[] args)
 Un tableau doit être
 Déclaré
 Créé
 Ses variables initialisées
int[] nombres; // déclaration
nombres = new int[10]; // création
int[] nombres = new int[10]; // déclaration et création
nombres[0] = 28;

41
Les tableaux (“Array”) (2/2)
 On peut construire des tableaux à plusieurs dimensions
 Des tableaux à plusieurs dimensions sont en fait des tableaux de tableaux
int[][] matrice = new int[3][];
« matrice » est une référence vers
un tableau contenant lui-même 3
tableaux de taille non définie
matrice[0] = new int[4];
Le premier élément de la matrice
est une référence vers un tableau
de 4 entiers,…
matrice[0][0] = 25;
Le premier élément du premier
tableau de la matrice est un entier
de valeur 25

IV. Premiers concepts d’orientés objets

43
Les concepts de l’Orienté Objet
Il faut penser à un objet comme à une variable améliorée
 Un objet stocke des données (attributs),
 Mais en plus on peut lui demander de faire des opérations sur lui-
même.
En théorie, on peut prendre n'importe quel composant
conceptuel du problème et le représenter en tant
qu'objet dans un programme.

44
Les concepts de l’Orienté Objet

45
Les concepts de l’OO
 Quelques exemples?
Objet États Comportements
Chien Nom, race, couleur, âge
Bill, Teckel, Brun, 1 an
Aboyer, chercher le
baton, mordre, faire le
beau
Compte N°, type, solde
N° 083-9876543-21, Epargne, 27.000 DH
Retrait, virement,
dépôt, consultation du
solde
Téléphone N°, marque, sonnerie, répertoire,
opérateur
Appeler, Prendre un
appel, Envoyer SMS,
Charger
Voiture Plaque, marque, couleur, vitesse
ABC-123, VW Polo, grise, 0 km/h
Tourner, accélérer,
s’arrêter, faire le plein,
klaxonner

46
 Comment les objets sont-ils définis?
Par leur classe, qui détermine toutes leurs caractéristiques
Nature des attributs et comportements possibles
La classe détermine tout ce que peut contenir un objet et tout ce qu’on
peut faire de cet objet
Classe = Moule, Définition, ou Structure d’un d’objet
Objet = Instance d’une classe
Une classe peut-être composite  peut contenir elle-même des objets
d’autres classes
Ex: Une voiture contient un moteur qui contient des cylindres…
Ex: Un chien possède des pattes…

47
 Quelques exemples?
 La classe « chien » définit:
 Les attributs d’un chien (nom, race, couleur, âge…)
 Les comportements d’un chien (Aboyer, chercher le baton, mordre…)
 Il peut exister dans le monde plusieurs objets (ou instances) de chien
Classe Objets
Chien Mon chien: Bill, Teckel, Brun, 1 an
Le chien de mon voisin: Hector, Labrador, Noir, 3 ans
Compte Mon compte à vue: N° 210-1234567-89, Courant, 1.734 €, 1250 €
Mon compte épargne: N° 083-9876543-21, Epargne, 27.000 €, 0 €
Voiture Ma voiture: ABC-123, VW Polo, grise, 0 km/h
La voiture que je viens de croiser: ZYX-987, Porsche, noire, 170 km/h

48
Orienté objet?
Un programme orienté objet est uniquement
constitué de classes interagissant par envoi de
messages
L’intégralité du code d’un programme orienté objet
se trouve donc à l’intérieur de classes

50
Codage de la classe « Voiture »

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

53
La création d’objets
La création d’un nouvel objet est obtenue par l’appel à
new NomClasse(paramètres)

54
Accès aux attributs
Pour accéder aux données d’un objet on utilise une notation
pointée
identificationObjet.nomAttribut

55
Envoi de messages : appel de méthodes
Pour « demander » à un objet d’effectuer un
traitement il faut lui envoyer un message
 Un message est composé de trois parties
 Une référence permettant de désigner l’objet à qui le message
est envoyé
 Le nom de la méthode ou de l’attribut à exécuter
 Les éventuels paramètres de la méthode
identificationObjet.nomDeMethode(« Paramètres éventuels »)
 Envoi de message similaire à un appel de fonction

56
Envoi de messages : appel de méthodes

57
PrincipesPOO
Les objets communiquent entre eux par des
messages
Un objet peut recevoir un message qui déclenche
 une méthode qui modifie son état
et / ou
 une méthode qui envoie un message à un autre objet

58
Les variables
Déclaration des variables membres (1/2)
 Une variable est un endroit de la mémoire à laquelle on a
donné un nom de sorte que l’on puisse y faire facilement
référence dans le programme
 Une variable a une valeur, correspondant à un certain
type
 La valeur d’une variable peut changer au cours de
l’exécution du programme
 Une variable Java est conçue pour un type particulier de
donnée

59
Les variables
Déclaration des variables membres (2/2)
 Rappel: toute variable doit être déclarée et initialisée
 Les variables membres sont des variables déclarées à
l’intérieur du corps de la classe mais à l’extérieur d’une
méthode particulière, elles sont donc accessibles depuis
n’importe où dans la classe.
 La signature de la variable :
 Les modificateurs d’accès: indiquent le niveau d’accessibilité de la variable
 [static]: permet la déclaration d’une variable de classe
 [final]: empêche la modification de la variable
 [transient]: on ne tient pas compte de la variable en sérialisant l’objet
 [volatile]: pour le multithreading
 Le type de la variable (ex: int, String, double, Point,…)
 Le nom de la variable (identificateur)
optionnel

60
Les variables
Portée d’une variable et des attributs
 Portée = Section du programme dans laquelle une variable existe
 La variable ne peut donc pas être utilisée en dehors de cette section
 La portée est définie par les accolades qui l’entourent directement
 Exemple:
 Avantages
 Rend les programmes plus faciles à corriger
 Limite le risque d’erreurs liées au réemploi d’un nom pour différentes variables
if(solde < 0){
String avertissement = "Attention, solde négatif !"
}
System.out.println(avertissement);
// Une erreur apparaîtra dès la compilation, car la variable
// « avertissement » n’existe pas en dehors du bloc IF

61
Les méthodes (1/3)
Déclaration d’une méthode
 Une méthode est composée de:
 Signature d’une méthode:
 Modificateurs d’accès : public, protected, private, aucun
 [modificateurs optionnels] : static, native, synchronized, final, abstract
 Type de retour : type de la valeur retournée
 Nom de la méthode (identificateur)
 Listes de paramètres entre parenthèses (peut être vide mais les parenthèses sont
indispensables)
 [exception] (throws Exception)
 Au minimum:
 La méthode possède un identificateur et un type de retour
 Si la méthode ne renvoie rien  le type de retour est void
 Les paramètres d’une méthode fournissent une information depuis
l’extérieur du “scope” de la méthode (idem que pour le constructeur)
public void deposit (int amount) {
}
solde+=amount ;
Sa déclaration
Son corps
Signature

62
Les méthodes (2/3)
L’interface d’une méthode
 L’interface d’une méthode, c’est sa signature
 Cette signature, qui définit l’interface de la méthode, correspond en
fait au message échangé quand la méthode est appelée
 Le message se limite de fait uniquement à la signature de la méthode
 Type de retour
 Nom
 Arguments
 L’expéditeur du message n’a donc jamais besoin de connaître
l’implémentation ou corps de la méthode
 On a donc:
 Déclaration = Signature = Message de la méthode
 Bloc d’instruction = Corps = Implémentation de la méthode

63
Les méthodes (3/3)
getters/setters
 Un getter (accesseur) est une méthode de la classe qui renvoie la
valeur d’une variable membre d’une classe
exemple:
Public int getSolde(){
return solde;
}
•Un setter (mutateur) est une méthode de la classe qui modifie la
valeur d’une variable membre d’une classe.
exemple:
Public void setSolde(int s){
solde=s;
}

64
La création d’objets (1/2)
Le constructeur
 A le même nom que la classe
 Quand un objet est créé, on invoque tout
d’abord le constructeur de la classe
 Un constructeur utilise comme arguments
des variables initialisant son état interne
 On peut surcharger les constructeurs, i.e
définir de multiples constructeurs
 Il existe toujours un constructeur. S’il n’est
pas explicitement défini, il sera un
constructeur par défaut, sans arguments
 Signature d’un constructeur:
 Modificateur d’accès ( en général public)
 Pas de type de retour
 Le même nom que la classe
 Les arguments sont utilisés pour initialiser les
variables de la classe
Public class BankAccount {
long number;
Int solde;
public BankAccount(long n,
int s)
{
number=n ;
solde=s;
}
public BankAccount(long n)
{
number=n;
solde=0;
}
…
}

65
La création d’objets (2/2)
L’appel au constructeur
 Se fait pour initialiser un objet
 Provoque la création réelle de l’objet en mémoire
 Par l’initialisation de ses variables internes propres
 Se fait par l’emploi du mot clé « new »
BankAccount ba1, ba2;
ba1 = new BankAccount(123456789, 10.000);
ba2 = new BankAccount(123456789);

66
Variables et méthodes "static"
 Le modificateur static est utilisé pour créer des variables
et des méthodes qui existent indépendamment de toutes
les instances créées pour la classe.
 toutes les instances d'une classe partagent la même
valeur pour toute variable déclarée avec le modificateur
"static".
 Les méthodes et les variables peuvent être déclarés avec
le modificateur "static".

67
Variables et méthodes "static"
 Exemple:
public class Point {
private double x,y;
private static int nombrePoint=0;
public Point(double x, double y) {
this.x = x;
this.y = y;
nombrePoint++;
}
public static int getNombrePoint(){
return nombrePoint;
}
Appel au méthode static:
Int n=Point.getNombrePoint();

68
TD1
 Ecrire une classe Point qui définit un point, et portant les caractéristiques
suivantes :
 La classe possède les attributs suivants :
 x : L'abscisse du point;
 y : L'ordonnée du point.
 La classe Point doit disposer des constructeurs suivants :
 Point();
 Point(x, y);
 Point(Point).
 La classe Point doit contenir des accesseurs (get) et mutateurs (set) pour les
différents attributs.
 La classe Point doit aussi contenir les méthodes :
 distance(x, y) : calcule la distance entre deux points;
 distance(Point) : calcule la distance entre deux points;
 deplacer(x, y) : déplace le point;
 toString() : donne une représentation du point (afficher l’abscisse et
l’ordonné avec 2 chiffre après la virgule).
 Ecrire une classe TestPoint afin de tester la classe Point.

69
TD2
 Ecrivez une classe Employe ayant les attributs suivants :
 nom : texte, le nom de famille de l’employé.
 prenom : texte, le prénom de l’employé.
 age : nombre, l'âge de l’employé compris entre 18 et 60 ans.
 salaire : nombre, le salaire de l’employé.
 La classe Employe doit posséder les constructeurs suivants :
 Employe();
 Employe(nom, prenom);
 Employe(nom, prenom, age);
 Employe(nom, prenom, age, salaire);
 Employe(Employe).
 La classe Employe doit contenir des accesseurs (get) et modificateurs (set)
pour tous les attributs.
 Redéfinissez la méthode toString() pour représenter les instances de la
manière de l’exemple ci-dessus:
Nom : Niyazi ; prénom : Ghizlane ; âge : 26 ans ;
Salaire : 8000 Dhs
Ecrivez une classe Test afin de tester votre code.

V. Types primitifs, des affectations et des valeurs

71
Les valeurs pour tous les types primitifs
 'b‘ // valeur char
 42 // valeur int
 false // valeur boolean
 2546789.343 // valeur double
 "b" // ce n’est pas une valeur de type char
 0 et 1 // elles ne sont pas des valeurs boolean, elles
sont //des valeur de type int

72
Affectations des primitifs
 Le signe égal (=) est utilisé pour attribuer une valeur à une variable, et il est
nommé l'opérateur d'affectation.
 Vous pouvez assigner une variable primitive utilisant une valeur ou le résultat
d'une expression.
 Regardez les exemples suivants:
int x = 7; // affecter une valeur
int y = x + 2; // affectation avec une expression
// (inclue une valeur)
int z = x * y; // affectation avec une expression

73
 Le point le plus important à retenir est que un entier (comme 7) est
toujours, implicitement, un int.
 Exécutez le code suivant:
byte a = 3; // Pas de problème, 3 fits in a byte
byte b = 8; // Pas de problème, 8 fits in a byte
byte c = a + b; // Ne devrait poser aucun problème, la somme est
inférieur // à 127
La dernière ligne ne compile pas! Vous obtiendrez une erreur quelque chose comme
ceci:
TestBytes.java:5: possible loss of precision
found : int
required: byte
byte c = a + b;
^

74
 Nous avons essayé d'attribuer la somme de deux valeurs byte à une
variable de type byte, dont le résultat (11) est assez petit pour tenir dans
un octet, mais le compilateur ne se souciait pas.
 Il aurait compilé si nous avions fait la conversion explicite:
byte c = (byte) (a + b);

75
La conversion des primitifs
 Casting vous permet de convertir les valeurs primitives d'un type à
l'autre.
 La conversion peut être implicite ou explicite. Une conversion
implicite signifie que vous n'avez pas à écrire code pour la
conversion , la conversion se fait automatiquement.
 Quand on essaie d’affecter une grande valeur à une variable
supposée contenir une valeur plus petit, on provoque une erreur de
compilation ("possible loss of precision")
 La conversion large-value-into-small-container nécessite une
conversion explicite, où vous dites au compilateur que vous êtes
conscients du danger et d'accepter la pleine responsabilité

76
 conversion implicite
int a = 100;
long b = a; // Implicit cast, an int value always fits in a
long
 conversion explicite
float a = 100.001f;
int b = (int)a; // Explicit cast, the float could lose info

77
 float f = 23.467890; // Compiler error, possible loss of
precision
 float g = 49837849.029847F; // OK; has the suffix "F"

79
The Stack and Heap
String s = new String (“hello”);
s
“hello”
java.lang.String
String est un type en Java
API pour representer une
séquences de caractéres

80
s
“hello”
java.lang.String
String t = s;
t

81
s
“hello”
java.lang.String
String t = s;
t
s = new String
(“goodbye”);
“goodbye”
java.lang.String

82
Types Immuable / Mutable
 Types peut être modifiable ou immuable
 Les objets d'un type immuable ne changent jamais de
valeur après leur création
 String est immuable

83
Java Semantics Question
public class Strings {
public static void test () {
String s = new String ("hello");
String t = new String ("hello");
s.concat (" goodbye!");
t = s.concat (" goodbye!"); } }
s
“hello”
java.lang.String
t
“hello”
java.lang.String

84
s
“hello”
java.lang.String
t
“hello”
java.lang.String
“hello
goodbye!”
java.lang.String

85
s
“hello”
java.lang.String
t
“hello”
java.lang.String
“hello
goodbye!”
java.lang.String
“hello
goodbye!”
java.lang.String

90
Relation d’appartenance
 classe B appartient à la classe A si le code de la
classe A a une référence à une instance de la classe
B.
Exemples:
 Moteur appartient à Voiture.
 Poignet appartient à Porte.

91
Relation d’appartenance
Exemple:
class Rectangle {
// point centre du rectangle
private Point centre;
// longueur du rectangle
private int longueur;
// largeur du rectangle
private int largeur;
...
}

92
TD
1. Construisez une classe Rectangle contenant un attribut privé
origine de type Point.
2. Écrivez un constructeur pour la classe Rectangle qui initialise
son origine à partir d'un point transmis en paramètre.
3. Un Rectangle possède deux attributs entiers privés longueur et
largeur en plus de son origine.
4. Écrivez un deuxième constructeur de la classe Rectangle avec
comme paramètres la largeur et la longueur qui initialise l’origine
à (0 ;0). On dit que ce constructeur surcharge le constructeur
écrit à la question 2).
5. Construisez des rectangles, dans votre classe de test, pour
vérifier votre code.
6. En vous inspirant de votre cours, ajoutez les méthodes
getPerimetre, getSurface, getLongueur, getLargeur,
setLongueur et setLargeur. Vérifiez leur validité en les testant.

94
Définition et intérêts
Héritage
 Technique offerte par les langages de programmation pour
construire une classe à partir d’une (ou plusieurs) autre classe en
partageant ses attributs et opérations.
Intérêts
 Spécialisation, enrichissement : une nouvelle classe réutilise les
attributs et les opérations d’une classe en y ajoutant et/ou des
opérations particulières à la nouvelle classe
 Redéfinition : une nouvelle classe redéfinit les opérations d’une
classe de manière à en changer le sens et/ou le comportement
pour le cas particulier défini par la nouvelle classe
 Réutilisation : évite de réécrire du code existant et parfois on ne
possède pas les sources de la classe à hériter

95
Spécialisation de la classe « Voiture »
Un véhicule prioritaire est une voiture avec un gyrophare
 Un véhicule prioritaire répond aux mêmes messages que la
Voiture
 On peut allumer le gyrophare d’un véhicule prioritaire
Une voiture électrique est une voiture dont l’opération de
démarrage est différente
 Une voiture électrique répond aux même messages que la
Voiture
 On démarre une voiture électrique en activant un disjoncteur

96
Spécialisation de la classe « Voiture »

97
Classes et sous-classes
Un objet de la classe VehiculePrioritaire ou VoitureElectrique est
aussi un objet de la classe Voiture donc il dispose de tous les
attributs et opérations de la classe Voiture

98
Classes et sous-classes : terminologie
Définitions
 La classe VehiculePrioritaire hérite de la classe Voiture
 Voiture est la classe mère et VehiculePrioritaire la classe fille
 Voiture est la super-classe de la classe VehiculePrioritaire
 VehiculePrioritaire est une sous-classe de Voiture
Attention
 Un objet de la classe VehiculePrioritaire ou VoitureElectrique est
forcément un objet de la classe Voiture
 Un objet de la classe Voiture n’est pas forcément un objet de la
classe VehiculePrioritaire ou VoitureElectrique

99
Généralisation et Spécialisation
La généralisation exprime une relation « est-un » entre
une classe et sa super-classe
L’héritage permet
de généraliser dans le sens abstraction
de spécialiser dans le sens raffinement
VehiculePrioritaire est une Voiture

100
Héritage et Java
Héritage simple
 Une classe ne peut hériter que d’une seule autre classe
 Dans certains autres langages (ex : C++) possibilité d’héritage multiple
 Utilisation du mot-clé extends après le nom de la classe

101
Héritage à plusieurs niveaux

102
Utilisation de l’héritage (2/3)
Les mots-clé « this » et « super »
 Dans le constructeur
 Il existe toujours un constructeur. S’il n’est pas explicitement défini, il
sera un constructeur par défaut, sans arguments
 « this » est toujours une référence sur l’objet en cours (de création) lui-
même
 « super » permet d’appeler le constructeur de la classe parent, ce qui
est obligatoire si celui-ci attend des arguments
class Child extends MyClass {
Child(){
super(6); // appel du constructeur
parent
}
}

103
Utilisation de l’héritage (3/3)
Les mots-clé « this » et « super »
 En cas de surcharge du constructeur:
class Employee {
String name,firstname;
Address a;
int age;
Employee(String name,String firstname,Address a,int age){
super();
this. firstname= firstname;
this.name=name;
this.a=a;
this.age=age;
}
Employee(String name,String firstname){
this(name,firstname,null,-1);
}

104
TD
 La classe Figure représente une figure quelconque. Les
figures particulières, telles des rectangles ou des ellipses,
seront représentées par des classes héritières de la classe
Figure.
 Le graphe suivant décrit les relations d'héritage et de clientèle
(ou agrégation) entre les différentes classes.
 Les relations d'héritage sont basées sur la relation « est-un »,
i.e. un Rectangle est-une Figure. En revanche, la relation de
clientèle correspond à une relation « a-un », i.e. une Figure (et
donc toutes ses classes héritières) a-un Point d'origine.

106
TD
1. Construisez une classe Figure en déplaçant l’attribut privé origine (de type
Point) de la classe Rectangle dans la classe Figure et en le rendant
accessible à ses classes dérivées (et seulement à elles).
2. Écrivez un constructeur pour la classe Figure qui initialise son origine à partir
d'un point transmis en paramètre.
3. Modifiez la classe Rectangle pour qu’elle hérite de la classe Figure. Un
Rectangle possède deux attributs entiers protégés longueur et largeur en plus
de son origine héritée de sa super classe Figure.
class Rectangle extends Figure {
// longueur du rectangle
protected int longueur;
// largeur du rectangle
protected int largeur;
}
4. Modifiez le constructeur de la classe Rectangle avec comme paramètres la
largeur et la longueur pour qu’il n’initialise plus l’origine dont il hérite, c’est la
classe Figure qui s’en charge. Ecrivez une classe de test et essayez de
construire un rectangle.

108
TD
Désigner les identificateurs incorrects à l’aide des cases à cocher
correspondantes :

109
TD
Pour le code source suivant, choisir la façon correcte d’appeler la méthode afficher() :
class Pyramide {
public int base = 0;
private static int brique = 1;
Pyramide() {
base += brique;
}
public static void afficher() {
System.out.print(brique);
}
}

110
TD
Soit la portion de code ci-dessous :
public static void main(String args[]){
String s1 = " une grande école d’ingénieurs s’installe, ";
String s2 = " à Casablanca, ";
s2 += s1 ;
System.out.println (s2);
}
 Dans la console
s’affiche : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . .
 Le nombre d’objets, de la classe String, créés est = . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

111
TD
Déterminer ; en justifiant ; les erreurs dans le code source suivant :
//Personnel.java
1 : Public class Personnel {
2 : static String 1NOM = "First Graphics";
3 : private static string verifier() {
4 : return 1NOM + ", c’est notre société! ";
4 : }
5 : public static void main(String[] argv){
7 : 1NOM = 3;
8 : verifier();
9 : }
10: }
11: class Admin extends Personnel {
12: public static void main(String[] args){
13: system.out.print("voilà : " + Personnel.verifier();
14: }
13: }

112
TD
Donner la sortie de chacune des portions de codes sources suivantes :
1)
Point p1=new Point(12.4,34.6);
System.out.printf("abscisse= %1.3f t ordonné=%1.3f n", p1.getAbscisse(),
p1.getOrdonne());
2)
System.out.printf("nombre d’objets crées est : %d points", 5);
3)
System.out.printf("nom : %s t prénom : %s","Bouysfi","Abdellatif");

113
TD
 Répondre au quizz suivant à l’aide des cases à cocher
correspondantes :

114
TD
 On souhaite traiter des comptes bancaires. Un compte bancaire possède à
tout moment une donnée entière, son solde. Il est caractérisé par ailleurs
par un code donné sous forme de chaîne de caractères, et un titulaire qui
est une personne physique. Ce solde peut être positif (compte créditeur) ou
négatif (compte débiteur).
 Au départ, un compte bancaire a un solde nul, un code nul par défaut et un
titulaire inconnu. Il est aussi possible de créer un compte en précisant son
solde initial, son titulaire et son code initial.
 Utiliser son compte consiste à pouvoir y faire des dépôts et des retraits.
Pour ces deux opérations il faut connaître le montant de l’opération et
vérifier que le code proposé est bien le code du compte.
 L’utilisateur peut aussi consulter le solde de son compte.
1) Ecrivez une classe PersonnePhysique, elle est décrite par un nom et prénom,
et comprendra les éléments suivants :
 Constructeur.
 Les accesseurs (get) et les mutateurs (set) pour les deux attributs.
 toString() : donne une représentation de l’objet personne.

115
TD
2) Ecrire une classe TestPersonne afin de tester la classe PersonnePhysique.
Console :
3) Ecrivez une classe CompteBancaire prenant en compte la description
précédente. Cette classe comprendra les éléments suivants :
 Constructeurs.
 Les accesseurs (get) et les mutateurs (set) pour les différents attributs.
 toString() : donne une représentation du compte bancaire.
 Une méthode de dépôt.
 Une méthode de retrait.

116
TD
4) Ecrivez une classe TestCompte afin de tester la classe CompteBancaire.
Console :

118
Redéfinition et Surcharge
• L’héritage
Une sous-classe peut ajouter des nouvelles méthodes à
celles qu’elle hérite.
Une sous-classe peut redéfinir (redéfinition) les méthodes
qu’elle hérite et fournit des implémentations spécifiques pour
celles-ci
• La Redéfinition (Overriding) : lorsque la sous-classe définit
une méthode dont le nom, les paramètres et le type de retour
sont identiques ( sauf le cas de Covariante).
• La surcharge (Overloding) : possibilité de définir des
méthodes possédant le même nom mais dont les arguments
sont différents.

119
Redéfinition (Overriding) d’une méthode
• Exemple:
Dans la classe Carre, on définit les deux méthodes setLongueur et
setLargeur, même si elles sont déjà définies dans la classe Rectangle.

120
Redéfinition (Overriding) d’une méthode
• Les règles à respecter pour redéfinir une méthode sont les
suivantes:
 La liste des arguments doit correspondre exactement à celle de la
méthode à redéfinir.
 Le type de retour doit être le même que celui déclaré
dans la méthode originale dans la classe mère.
 Vous ne pouvez pas redéfinir une méthode marquée « final ».
 Vous ne pouvez pas redéfinir une méthode marquée « static ».
 Si une méthode ne peut pas être héritée, vous ne pouvez pas la
redéfinir(une méthode marquée private dans la classe mère ne peut
pas être hérité).
 Le niveau d'accès ne peut pas être plus restrictive que celui de la
méthode à redéfinir.
 Le niveau d'accès peut être moins restrictive que celle de la méthode
à redéfinir.

121
Surcharge (Overloding) d’une méthode
• Les règles à respecter pour surcharger une
méthode sont les suivantes:

123
Héritage
 Qu’est-ce que le polymorphisme?
 Concept basé sur la notion de redéfinition de méthodes
 Permet à une tierce classe de traiter un ensemble de classes sans connaître
leur nature ultime
 Permet de factoriser des dénominations d’activité mais pas les activités elles-
mêmes
 Consiste à permettre à une classe de s’adresser à une autre en sollicitant un
service générique qui s’appliquera différemment au niveau de chaque sous-
classe du destinataire du message
 En d’autres termes, permet de changer le comportement d’une classe de base
sans la modifier  Deux objets peuvent réagir différemment au même appel
de méthode
 Uniquement possible entre classes reliées par un lien d’héritage
 Exemple dans l’écosystème?
 Demander à tous les animaux de se déplacer (selon leurs propres règles) en
leur adressant un message en tant qu’objets de type “Faune”

124
Utilisation de l’héritage
Redéfinition de méthodes
 La redéfinition n’est pas obligatoire !! Mais elle permet d’adapter un
comportement et de le spécifier pour la sous-classe.
 Obligation de redéfinir les méthodes déclarées comme abstraites (abstract)
 Interdiction de redéfinir les méthode déclarées comme finales (final)
class BankAccount {
public void computeInterest(){
solde+=300; //annual gift
}}
class NormalAccount extends BankAccount {
public void computeInterest(){
super.computeInterest();//call the overriden method
solde*=1.07; //annual increase
}}

125
Polymorphisme (1/2)
Définition
 Concept basé sur la notion de redéfinition de méthodes
 Consiste à permettre à une classe de s’adresser à une autre en sollicitant
un service générique qui s’appliquera différemment au niveau de chaque
sous-classe du destinataire du message
 En d’autres termes, permet de changer le comportement d’une classe de
base sans la modifier  Deux objets peuvent réagir différemment au
même appel de méthode
 Uniquement possible entre classes reliées par un lien d’héritage et
suppose un cast « vers le haut » des objets des classes enfants
class Bank{
BankAccount[] theAccounts = new BankAccount[10];
public static void main(String[] args){
theAccounts[0] = new NormalAccount("Joe",10000);
theAccounts[0].computeInterest();
}}

126
Polymorphisme (2/2)
Utilisation du polymorphisme sur des collections hétérogènes
BankAccount[] ba=new BankAccount[5];
ba[0] = new NormalAccount("Joe",10000);
ba[1] = new NormalAccount("John",11000);
ba[2] = new SpecialAccount("Jef",12000);
ba[3] = new SpecialAccount("Jack",13000);
ba[4] = new SpecialAccount("Jim",14000);
for(int i=0;i<ba.length();i++)
{
ba[i].computeInterest();
}

VII. Modificateurs d’accès aux classes,
méthodes et attributs

128
L’accès à une classe
Lorsque nous disons que le code d'une classe
(classe B) a l'accès à une autre classe (classe A), cela
signifie que la classe B peut faire un de trois choses:
 Crée une instance de la classe A.
 hérite la classe A (en d'autres termes, devenir une sous-
classe de la classe A).
 L'accès à certaines méthodes et attributs de la classe A.

129
Les modificateurs d’accès d’une classe : Public et
Default
 Une classe avec accès par défaut n'a pas de modificateur le
précède dans la déclaration. C'est le contrôle d'accès vous
obtenez lorsque vous ne tapez pas un modificateur dans la
déclaration.
 Une classe d’accès par défaut ne peut être vu que par classes
au sein de même package.
 Si classe A et classe B sont dans différents paquets et classe A a
accès par défaut, la classe B ne sera pas en mesure d’accéder à
classe A.

130
Une classe avec accès Public est vue par toutes les classes.
En d'autres termes, toutes les classes de Java Univers (JU) ont accès à
un public class.
Nous pourrons avoir besoin de ne pas placer les deux classes Voiture
et VoiturePrioritaire dans le même paquet. Donc Voiture doit avoir un
accès Public, et il faut importer la classe Voiture.
package package1;
Public class Voiture {
…
}
package package2;
Import package1.Voiture;
classe VoiturePrioritaire extends Voiture{
…
}
Fichier Voiture.java Fichier Voiture2.java

131
Le fichier source
les règles associées à la déclaration des classes, des déclarations
d'importation et la déclaration du paquet dans un fichier source:
 Il ne peut y avoir seulement une classe publique par fichier de
code source.
 Les commentaires peuvent apparaître au début ou à la fin de
n'importe quelle ligne dans le code source des fichiers, ils sont
indépendants des règles de positionnement en question ici.
 S'il y a une classe publique dans un fichier, le nom du fichier et le
nom de la classe doivent être les même. Par exemple, une
classe déclarés public class Voiture doit être dans le fichier
source nommé Voiture.java

132
Le fichier source
Si la classe est partie d'un paquet, le paquet doit être la
première ligne dans le code source du fichier, avant toute
déclaration d’importation qui peut être présente.
S'il ya des déclarations d'importation, ils doivent être
placées entre la déclaration du paquet (s'il y en a une) et
la déclaration de la classe. Si il n‘y a pas une déclaration
du paquet , la déclaration d'importation (s) doit être la
première ligne (s) dans le code source. Si il n'existe pas
de paquet ou des déclarations d'importation, la
déclaration de la classe doit être la première ligne dans le
code source.

133
Le fichier source
La déclaration du paquet et l'ensemble des déclarations
d’importation s'appliquent à toutes les classes au sein
d'un fichier de code source.
Un fichier peut avoir plus d'une classe non publique.
Un fichier de code source qui n’a pas une classe public
peut avoir un nom différent de ces classes.

134
Classe et visibilité des attributs
Caractéristique d’un attribut
 Variables « globales » de la classe
 Accessibles dans toutes les méthodes de la classe

135
Distinction entre attributs et variables
Caractéristique d’une variable
 Visible à l’intérieur du bloc qui le définit

136
L’accès aux membres d’une classe A par une
classe B
Une classe B a l’accès à un membre X de la classe A
signifie:
 Code d’une méthode de la classe B peut accéder au membre X.
 La classe B peut hériter le membre X.

137
Comparaison entre l’accès à un membre par
héritage et par l’opérateur .dot

138
Les modificateurs d’accès d’un membre ( méthode
ou attribut)
Nous venons d’examiner ce que signifie
d'utiliser un modificateur de classe dans une
déclaration, et maintenant nous allons étudier ce que
cela signifie avec les membres d’une classe.

139
ou attribut)
Parce que les membres données et méthodes
prennent le contrôle d'accès exactement de la même
manière, nous allons les couvrir à la fois dans cette
section.

140
ou attribut)
une classe ne peut utiliser que deux des quatre niveaux
de contrôle d'accès (public ou par défaut), les membres peuvent
utiliser les quatre:
public
protected
Default
private

141
Les modificateurs d’accès d’un membre (méthode
ou attribut)
Public Members
Quand un membre (attribut ou méthode) est déclaré public,
cela implique que toutes les autres classes, quel que soit le paquet
auquel ils appartiennent, peuvent accéder à ce membre (en
supposant que la classe elle-même est visible).

142
ou attribut)

143
ou attribut)
Private Members
l’accès à un membre marqué private se fait
seulement à partir de la classe dans laquelle il est
déclaré.

144
ou attribut)

145
ou attribut)
Default Members
l’accès à un membre marqué Default se fait
seulement dans le paquet dans lequel il appartient.

146
ou attribut)

147
ou attribut)
Protected Members
les modificateurs d’accès Protected et Default sont presque
identiques, mais avec une différence critique. Un membre déclaré
Protected peut être accédé (par héritage) par une sous-classe,
même si la sous-classe est dans un paquet différent.

148
ou attribut)

149
Les avantages de l’OO
 Les programmes sont plus stables, plus robustes et plus faciles à
maintenir car le couplage est faible entre les classes («encapsulation»)
 elle facilite grandement le ré-emploi des programmes: par petite
adaptation, par agrégation ou par héritage
 émergence des «design patterns»
 il est plus facile de travailler de manière itérée et évolutive car les
programmes sont facilement extensibles. On peut donc graduellement
réduire le risque plutôt que de laisser la seule évaluation pour la fin.
 l’OO permet de faire une bonne analyse du problème suffisamment
détachée de l’étape d’écriture du code - on peut travailler de manière très
abstraite  UML
 l’OO colle beaucoup mieux à notre façon de percevoir et de découper le
monde

150
Les avantages de l’OO
 Tous ces avantages de l’OO se font de plus en plus évidents avec le
grossissement des projets informatiques et la multiplication des acteurs.
Des aspects tels l’encapsulation, l’héritage ou le polymorphisme prennent
vraiment tout leur sens. On appréhende mieux les bénéfices de langage
plus stable, plus facilement extensible et plus facilement ré-employable
 JAVA est un langage strictement OO qui a été propulsé sur la scène par
sa complémentarité avec Internet mais cette même complémentarité (avec
ce réseau complètement ouvert) rend encore plus précieux les aspects de
stabilité et de sécurité

151
En résumé
 Tout est un objet
 L’exécution d’un programme est réalisée par échanges de messages entre
objets
 Un message est une demande d’action, caractérisée par les paramètres
nécessaires à la réalisation de cette action
 Tout objet est une instance de classe, qui est le « moule » générique des
objets de ce type
 Les classes définissent les comportements possibles de leurs objets
 Les classes sont organisées en une structure arborescente à racine unique :
la hiérarchie d’héritage
 Tout le code des programmes de trouve entièrement et exclusivement dans le
corps des classes
 A l’exception toutefois de deux instructions:
 package  définit l’ensemble auquel la classe appartient
 import  permet l’utilisation de classes extérieures au package
 UML permet la représentation graphique des applications

Java programmation OO, héritage et polymorphisme

Contenu connexe

Similaire à Java programmation OO, héritage et polymorphisme (20)

Dernier (16)

Java programmation OO, héritage et polymorphisme