Cours-2019

Université Abdelmalek Essaâdi
Ecole Nationale des Sciences Appliquées
de Tétouan
Programmation Orientée Objet
Java
Module: Modélisation et POO
1 ère Année GSTR / GM
Année Universitaire
2018/2019
PLAN
 Introduction,
 Les bases du langage
 Classe et Objet
 Tableaux
 Héritage
 Polymorphisme
 Classe Abstraite, Interface,
 JDBC et Swing
Introduction
3
3
Caractéristiques de Java

Un langage Orienté Objet
•

pas de variables ni de fonctions globales, types primitifs et objet
Simple


sûr
•

ramasse miettes, fortement typé, gestion des exceptions
Indépendant d ’une architecture
•

pas de pointeurs, vérification du code à l ’exécution et des accès réseau
et/ou fichiers
Robuste
•

syntaxe C/C++ (types primitifs, instructions de test et boucles, …)
Portabilité assurée par la présence d ’un interpréteur de bytecode sur
chaque machine
Environnement riche

classes standard complètes

classes pour les communications réseau
4

fonctions graphiques évoluées
Portable
public class Bonjour{
•
Le
source Java
Bonjour.java
…
}
1) compilation
JDK
Le • fichier compilé
Bonjour.class
1100 1010 1111 1110 1011 1010 1011 1110
0000 0011 0001 1101 …………………...
Lecture du fichier locale ou distante
jvm
jvm
jvm
sun
mac
pc
2) interprétation
JRE
Sun
solaris
Mac
pc
MacOS
Windows
5
Environnement d’Exécution

En informatique, JRE est le sigle de Java Runtime Environment
(« environnement d'exécution Java ») et désigne un ensemble d'outils
permettant l'exécution de programmes Java sur toutes les platesformes supportées.

JRE est constitué d'une JVM (Java Virtual Machine - Machine
Virtuelle Java), le programme qui interprète le code Java compilé
(bytecode) et le convertit en code natif. Mais le JRE est surtout
constitué d'une bibliothèque standard à partir de laquelle doivent être
développés tous les programmes en Java. C'est la garantie de
portabilité qui a fait la réussite de Java dans les architectures clientserveur en facilitant la migration entre serveurs.

Cet outil est à distinguer du JDK (Java Development Kit) qui est
constitué en plus d'outils de développement permettant
essentiellement de compiler du code Java pour produire du bytecode
qui sera interprété par la machine virtuelle sur le poste utilisateur.
6
Mots clés

Mots clés du langage
abstract
default
private
break
continue
for
new
switch
package
boolean
do
if
this
double
implements
protected byte
else
import
public
case
instanceof
return
transient
catch
extends
int
short
try
char
final
interface
static
void
class
long
float
super
while
7
Types de données

Types de données primitives
Nom
Taille (bit)
Plage des valeurs
Valeur par
défaut
byte
8
-128 … 127
0
short
16
-32 768 … 32 767
0
int
32
-2 147 483 648 … 2 147 483 647
0
long
64
-9 223 372 036 854 775 808 …
9 223 372 036 854 775 807
0L
float
32
3.4e-38 … 3.4e+38
0.0f
double
64
1.7e-308 … 1.7e308
0.0d
true ou false
false
'\u0000' (0) … '\uffff' ( 65,535 inclusive).
'\u0000'
boolean
char
16
8
Premier Programme
import java.io.*;
public class Bonjour {
public static void main(String args[]) {
System.out.println("Bonjour le monde!");
}
}Compilation (JDK)
C:\prog_java\> javac Bonjour.java
 Création de Bonjour.class
Exécution
C:\prog_java\> java Bonjour
Attention: Une configuration requise
2ème programme: Afficher bonjour en tenant compte d'un éventuel
paramètre passé sur la ligne de commande
public class Bonjour2 {
public static void main(String args[]) {
if (args.length==0)
System.out.println("Bonjour le monde!");
else System.out.println("Bonjour "+args[0]+" ! ");
}
}
9
Environnement de développement

Quel environnement de développement (IDE) pour mon Hello world?
Eclipse (plus complet soutenu par IBM)
10
NetBeans (soutenu par Sun)
Environnement de développement

Java est-il encore à la mode? www.tiobe.com
11
Environnement de développement

Java est-il encore à la mode? www.tiobe.com
12
Environnement (très) riche

java.applet

java.awt

java.io

java.lang

java.math

java.net

java.rmi

java.security

java.sql

java.util

javax.swing

org.omg.CORBA

….

Liste des principaux paquetages de la plate-forme JDK 1.2

soit environ 1500 classes !!! Et bien d ’autres A.P.I. JSDK, JINI, ...

le JDK1.3/1850 classes

JDK 1.4 encore plus, déjà le JDK 1.5, 1.6, 1.7, 1.8 ….
13
Packages
Le package java.lang
•Le package java.lang est chargé automatiquement, ses classes sont donc
toujours utilisables. On y trouve, entre autres :
•la classe Object dont dérivent toutes les autres classes
•les classes représentant les types numériques de bases : Boolean, Byte,
Double, Float, Integer, Long
•la classe Math qui fournit des méthodes de calcul des fonctions usuelles en
mathématiques
•les classes Character, String et StringBuffer pour la gestion des caractères et
des chaînes de caractères
•la classe System que nous utilisons pour afficher du texte sur la console DOS.
Les autres packages
Les autres packages doivent être déclarés (mot clé import) pour pouvoir être
utilisés.
Nous aurons à étudier entre autres, les packages
java.awt pour la création d'interfaces graphiques
java.awt.event pour la gestion des évènements
java.util pour certaines structures de données
java.io pour la gestion des fichiers
Etc.
14
Variables et Objets
Types Java
Une variable est :
• soit de type primitif
• soit une référence à un objet
Types primitifs
boolean
byte
short
int
long
char
int x, y;
boolean b = false;
double d = 3.14159;
float
double
Types de références
Object
PolygoneRegulier unPolygone = new
PolygoneRegulier();
Carre unCarre = new Carre();
Object o = new Object();
Type Tableau
Type Classe
Type interface
15
Programmation Orientée Objet
Notions de base
16
16
Exemples: 1 classe par fichier
/** Modélise un point de coordonnées x, y */ public
class Point {
private int x, y;
public Point(int x1, int y1) { x = x1; y = y1;
}
public double distance(Point p) {
return Math.sqrt((x-p.x)*(x-p.x) + (y-p.y)*(y-p.y));
}
}
/** Teste la classe Point */
class TestPoint {
public static void main(String[] args) {
Point p1 = new Point(1, 2); Point p2 = new Point(5, 1);
System.out.println("Distance : " + p1.distance(p2));
}
}
Fichier Point.java
17
Compilation et exécution de la classe Point
La compilation du fichier Point.java
javac Point.java fournit 2 fichiers classes :
Point.class
et TestPoint.class
 On lance l’exécution de la classe TestPoint
qui a une méthode main(): java TestPoint

18
Architecture générale d’un programme Java
Programme source Java = ensemble de fichiers
« .java »


Chaque fichier « .java » contient une ou plusieurs
définitions de classes

Au plus une définition de classe public par fichier « .java
» avec nom du fichier = nom de la classe publique
19
Notion d’objet en Java



Un objet a:
– une adresse en mémoire (identifie l’objet)
– un comportement
– un état interne
L’état interne est donné par des valeurs de
variables d’instances
Le comportement est donné par des fonctions ou
procédures, appelées méthodes
20
Exemple classe etudiant
Etudiant
String nom
String prénom int numéro
void Changer_nom(string)
void Changer_numero(string)
…
21
Exemple classe etudiant
Public class Etudiant { private string nom, prenom;
private int numero;
// constructeur
public Etudiant(String unnom, String unprenom, int unnumero) {
nom = unnom;
prenom = unprenom;
numero = unnumero;
}
// méthodes
Public string getnom() {
// accesseur
return nom;
}
Public void changernumero(int unnum) {
numero = unnum;
}
}
/ / modificateur
22
Constructeurs d’une classe
Chaque classe a un ou plusieurs
constructeurs qui servent à:
– créer les instances
– initialiser l’état de ces instances
Un constructeur:
– a le même nom que la classe
– n’a pas de type retour
23
Création d’une instance
public class Employe {
private String nom, prenom;
private double salaire;
// Constructeur
public Employe(String n, String p) {
nom = n;
prenom = p;
}
public void setSalaire(double s){
salaire=s;
}
...
public static void main(String[] args)
{ Employe e1;
e1 = new Employe("karim", "alami");
e1.setSalaire(12000);
...
}
}
variables
d’instance
création d'une instance
de Employe
24
Désigner un constructeur par this()
public class Employe {
private String nom, prenom;
private double salaire;
public Employe(String n, String p, double s) {
nom = n; prenom = p; salaire = s;
}
// Ce constructeur appelle l'autre constructeur
public Employe(String n, String p) { this(n, p, 0);
}
...
e1 = new Employe("Dupond", "Pierre");
e2 = new Employe("Durand", "Jacques", 15000);
25
Constructeur par défaut
Lorsque le code d’une classe ne comporte
pas de constructeur, un constructeur sera
automatiquement ajouté par Java.
Pour une classe Classe, ce constructeur
sera par défaut défini par Java
[public] Classe() { }
26
Constructeurs
Plusieurs
constructeurs sont possibles
INSTANCES
CLASSE
public class Point {
// ...
Point p = new Point(1,2);
`
Point(double ax,double ay) {
x = ax;
y = ay;
}
Point() {
Point q = new Point();
x = 0;
y = 0;
}
}
27
Constructeurs par défaut
public class Point {
public double x;
Point p = new Point();
CLASSE
public double y;
Point q = new Point(1,2);
}
refusé à la compilation
INSTANCES
Point p = new Point();
public class Point {
public double x;
INSTANCES
CLASSE
public double y;
Point q = new Point(1,2);
Point(double ax,double ay) {
x = ax;
y = ay;
}
}
public class Point {
// ...
CLASSE
Point(double x,double y) {
x = x;
y = y;
ambiguité!
public class Point {
// ...
void Point(double x,double y) {
this.x = x;
this.y = y;
}
}
Point() {
void Point() {
x = 0;
y = 0;
redondance
CLASSE
this(0,0);28
}
Constructeurs par copie
CLASSE
public class Point {
INSTANCES
Point p = new Point(1,2);
public double x;
public double y;
Point q = new Point(p);
Point(double ax,double ay) {
x = ax;
y = ay;
}
Point(Point p) {
this(p.x,p.y);
}
}
29
Classes et Objets
Exercice :

Définir une classe Livre avec les attributs suivants : Titre, Auteur (Nom
complet), Prix.

Définir les méthodes d’accès aux différents attributs de la classe
(getters et setters)

Définir un constructeur surchargé permettant d’initialiser les attributs
par des valeurs saisies par l’utilisateur.

Définir la méthode Afficher ( ) permettant d’afficher les informations du
livre en cours.

Écrire un programme testant la classe Livre.
30
Surcharge d’une méthode
En Java, on peut surcharger une méthode,
c’est-à- dire, ajouter une méthode qui a le
même nom mais pas la même signature
qu’une autre méthode :
calculerSalaire(int)

calculerSalaire(int, double)

Signature d’une méthode = Nom +
Paramètres
31
Surcharge d’une méthode
En Java, il est interdit de surcharger une
méthode en changeant le type de retour

Autrement dit, on ne peut différencier 2
méthodes par leur type retour
Par exemple, il est interdit d'avoir ces 2
méthodes dans une classe :

int calculerSalaire(int)
double calculerSalaire(int)
!
32
Déclaration / création
public static void main(String[]
args) {
Employe e1;
provoque une erreur
NullPointerException
e1.setSalaire(12000);

« Employe e1; » déclare que l’on va utiliser
une variable e1 qui référencera un objet de
la classe Employe, mais aucun objet n’est
créé
33
Types d'autorisation d'accès
private : seule la classe dans laquelle il est
déclaré a accès (à ce membre ou constructeur)

public : toutes les classes sans exception y ont
accès

Sinon, par défaut, seules les classes du même
paquetage que la classe dans lequel il est déclaré y
ont accès (un paquetage est un regroupement de
classes )

34
Classes et Objets
Exercice :
Définir une classe Employé caractérisée par les attributs :
Matricule, Nom, Prénom, AnneeNaiss, AnneeEmbauche, Salaire.

Définir les méthodes d’accès aux différents attributs de la classe,

Définir un constructeur surchargé

Ajouter à la classe la méthode getAge( ) qui retourne l’âge de
l’employé.

Ajouter à la classe la méthode getAnciennete( ) qui retourne le nombre
d’années d’ancienneté de l’employé.

Ajouter à la classe la méthode AugmentationDuSalaire( ) qui
augmente le salaire de l’employé en prenant en considération
l’ancienneté. Si Ancienneté < 5 ans, alors on ajoute 2%. - Si
Ancienneté < 10 ans, alors on ajoute 5%. - Sinon, on ajoute 10%.

Ajouter la méthode AfficherEmployé()

Ecrire un programme de test pour la classe Employé.
35
Variables de classe
Variables de classe( ou variables static)

Certaines variables sont partagées par toutes les
instances d’une classe. Ce sont les: variables de
classe (modificateur static)

Si une variable de classe est initialisée dans sa
déclaration, cette initialisation est exécutée une
seule fois quand la classe est chargée en
mémoire
36
Exemple de variable de classe
public class Employe {
private String nom, prenom;
private double salaire;
private static int nbEmployes = 0;
// Constructeur
public Employe(String n, String p) { nom = n;
prenom = p;
nbEmployes++;
}
...
}
37
Méthodes de classe

Une méthode de classe (modificateur static
en Java) exécute une action indépendante
d’une instance particulière de la classe
Exemple :
public static int getNbEmployes() {
return nbEmployes;
}

38
Désigner une méthode de classe

Pour désigner une méthode static depuis
une autre classe, on la préfixe par le nom de
la classe :
int n = Employe.getNbEmploye();

On peut aussi la préfixer par une instance
quelconque de la classe (à éviter car cela nuit
à la lisibilité : on ne voit pas que la méthode
est static) :
int n = e1.getNbEmploye();
39
Méthodes de classe

Comme une méthode de classe exécute une
action indépendante d’une instance particulière
de la classe, elle ne peut utiliser de référence à
une instance courante (this)
40
La méthode static main
La méthode main() est nécessairement static.
Pourquoi ?
 La méthode main() est exécutée au début du
programme. Aucune instance n’est donc déjà créée
lorsque la méthode main() commence son
exécution.
 Ça ne peut donc pas être une méthode d’instance.

41
Blocs d’initialisation static

Ils permettent d’initialiser les variables static trop
complexes à initialiser dans leur déclaration :
class UneClasse {
public static int[] tab = new int[25];
static {
for (int i = 0; i < 25; i++) { tab[i] = -1;
}
}
...
 Ils sont exécutés une seule fois, quand la classe est
chargée en mémoire
 Pour désigner la variable static à partir d’une autre
classe: UneClasse.tab[i]
42
Types de données en Java

Toutes les données manipulées par Java
ne sont pas des objets

2 grands groupes de types de données :
– types primitifs
– objets (instances de classe)
43
Types primitifs
boolean (true/false)
Nombres entiers : byte (1 octet), short (2
octets), int (4 octets), long (8 octets)
Nombres non entiers, à virgule flottante :
float (4 octets), double (8 octets)
Caractère : char (2 octets) ; codé par le
codage Unicode (et pas ASCII)

44
Objets et types primitifs

Java manipule différemment les types
primitifs et les objets
– les types primitifs sont manipulés par
valeurs
– les objets sont manipulés par références
45
Exemple d’utilisation des références






int m() {
A a1, a2;
a1 = new A();
a2 = a1;
...
}
Que se passe-t-il lorsque la méthode
m() est appelée ?
46
Exemple d’utilisation des références
int m() {
A a1 = new A();
A a2 = a1;
Références
a1 a2
Pile
Tas
47
Exemple d’utilisation des références
int m() {
A a1 = new A();
A a2 = a1;
}
Références
a1 a2
Pile
Instance de A
Tas
48
Exemple d’utilisation des références
int m() {
A a1 = new A();
A a2 = a1;
Références
a1
Instance de A
a2
Pile
Tas
49
Exemple d’utilisation des références
int m() {
A a1 = new A();
A a2 = a1;
Références
a1
Instance de A
a2
Pile
Tas
50
Exemple d’utilisation des références
int m() {
A a1 = new A();
A a2 = a1;
}
Après l’exécution de la méthode
m(), l’instance de A n’est plus
référencée mais reste dans le tas
Instance de A
Pile
Tas
51
Exemple d’utilisation des références
...le ramasse-miette interviendra à un
moment aléatoire...
Pile
Tas
52
Ramasse-miettes
Le ramasse-miettes (garbage collector) est une tâche
qui
– travaille en arrière-plan
– libère la place occupée par les instances non
référencées
– compacte la mémoire occupée
Il intervient
– quand le système a besoin de mémoire
– ou, de temps en temps, avec une priorité faible

53
Modificateur final


Le modificateur final indique que la valeur de
la variable ne peut être modifiée
On pourra lui donner une valeur une seule
fois dans le programme
54
Variable de classe final
Une variable de classe static final est
constante dans tout le programme ; exemple :
static final double PI = 3.14;

Une variable de classe static final peut ne pas
être initialisée à sa déclaration mais elle doit
alors recevoir sa valeur dans un bloc
d'initialisation static

55
Variable d’instance final


Une variable d’instance (pas static) final est
constante pour chaque instance ; mais elle
peut avoir 2 valeurs différentes pour 2
instances
Une variable d'instance final peut ne pas être
initialisée à sa déclaration mais elle doit avoir
une valeur à la sortie de tous les constructeurs
56
Variable final
Si la variable est d’un type primitif, sa valeur
ne peut changer
 Si la variable référence un objet, elle ne pourra
référencer un autre objet mais l’état de l’objet pourra être
modifié
final Employe e = new Employe("alami");
...
e.nom = "karim"; // Autorisé !
e.setSalaire(12000); //Autorisé !
e = new Employe("Bob"); // Interdit

57
Forcer un type en Java
Java est un langage fortement typé
Dans certains cas, il est nécessaire de forcer le
programme à considérer une expression comme
étant d’un type qui n’est pas son type réel ou déclaré
On utilise pour cela le cast (transtypage) : (type-forcé)
expression

int x = 10, y = 3;
// on veut 3.3333.. et pas 3.0
double z = (double)x / y; // cast de x suffit
58
Casts autorisés
En Java, 2 seuls cas sont autorisés pour les
casts :
– entre types primitifs,
– entre classes mère/ancêtre et classes filles
(on verra ce cas lors du cours sur l’héritage)

59
Les tableaux sont des objets
En Java les tableaux sont considérés comme des
objets (dont la classe hérite de Object) :
–les variables de type tableau contiennent des références
aux tableaux
–les tableaux sont créés par l’opérateur new
–ils ont une variable d’instance (final) : final int length

60
Mais des objets particuliers

Cependant, Java a une syntaxe particulière pour
– la déclaration des tableaux
– leur initialisation
61
Déclaration et création des tableaux
Déclaration : la taille n’est pas fixée
int[] tabEntiers;
Déclaration « à la C » possible, mais pas recommandé :
int tabEntiers[];
 Création : on doit donner la taille
tabEntiers = new int[5];
Chaque élément du tableau reçoit la valeur par défaut
du type de base du tableau
 La taille ne pourra plus être modifiée par la suite

62
Tableaux à plusieurs dimensions

Déclaration

int[][] notes;

Chaque élément du tableau contient une référence vers un tableau

Création

Chacun des 30 étudiants
a au plus 3 notes
notes = new int[30][3];
notes = new int[30][];
Il faut donner au moins
les premières dimensions
Chacun des 30 étudiants
a un nombre de notes
variable
63
Exemple Tableau
public class Exemple4 {
public static void main (String[] args ) {
int [] tab = new int[100];
// déclaration d’un tableau de 100 cases
Scanner clavier= new Scanner (System.in);
// remplissage du tableau par des valeurs saisies par l’utilisateur
for ( int i=0 ;i<100 ;i++ ) {
System.out.println ("entrer la valeur numéro : "+i) ;
tab[i] = clavier.nextInt(); }
// Affichage du tableau
for ( int i=0 ;i<100 ;i++ ) {
System.out.print(tab[i]+ " ") ;
} }
}
64
EXERCICES
Exercice 1:
Soit le tableau suivant :
int[] tab = {-1, 15, -3, 10, -8, -9, 13, 14};
Ecrire
un
programme
positives(som_positive)
qui
calcule
et
la
la
somme
somme
des
des
valeurs
valeurs
négatives(som_negative).
Exercice 2:
Ecrire un programme java qui permet de remplir dans un tableau de
chaînes de caractères les noms de 30 étudiants. Afficher ensuite les noms
qui commencent par ‘e’ ou ‘E’;
65
Instructions de contrôle
Alternative « if …else »
if (expressionBooléenne)
bloc-instructions ou
instruction
else
bloc-instructions ou
instruction
int x = y + 5; if (x % 2 == 0)
{
type = 0;
x++;
}
else
type = 1;
66
Expression conditionnelle
expressionBooléenne ? expression1 :
expression2
int y = (x % 2 == 0) ? x + 1 : x;
est équivalent à
int y;
if (x % 2 == 0) y = x + 1

else
y = x;
67
Distinction de cas suivant une valeur
switch(expression) { case val1: instructions; break;
...
case valn: instructions;
break;
default: instructions;
}
Sans break les instructions du cas suivant sont exécutées !
expression est de type char, byte, short, ou int, ou de type
énumération
S’il n’y a pas de clause default, rien n’est exécuté si
expression ne correspond à aucun case
68
Répétitions « tant que »
while(expressionBooléenne)
bloc-instructions ou instruction

do
bloc-instructions ou instruction
while(expressionBooléenne)

69
Répétition for
for(init; test;
incrément){
instructions;
}
est équivalent à
init;
while (test) {
instructions;
incrément
}
70
Exemple de for
int somme = 0;
for (int i=0; i < tab.length; i++) {
somme += tab[i];
}
System.out.println(somme);
71
« for each »
Une nouvelle syntaxe introduite par la version
5 du JDK simplifie le parcours d’un tableau
La syntaxe est plus simple/lisible qu’une
boucle for ordinaire
Attention, on ne dispose pas de la position
dans le tableau (pas de « variable de boucle »)
On verra par la suite que cette syntaxe est
encore plus utile pour le parcours d’une «
collection »

72
Parcours d’un tableau
String[] noms = new String[50];
...
// Lire « pour chaque nom dans noms »
// « : » se lit « dans »
for (String nom : noms) {
System.out.println(nom);
}
73
Instructions liées aux boucles
break sort de la boucle et continue
après la Boucle

continue passe à l’itération suivante

74
Passage des arguments des méthodes

Le passage se fait par valeur (les valeurs des
arguments sont recopiées dans l’espace
mémoire de la méthode)

Attention, pour les objets, la valeur passée est
une référence ; donc,
– si la méthode modifie l’objet référencé par un
paramètre, l’objet passé en argument sera modifié en
dehors de la méthode
75
Exemple de passage de paramètres

public static void m(int ip, Employe e1p, Employe e2p) {
ip = 100;
e1p.salaire = 800;
e2p = new Employe("Ali", 900);
}
public static void main(String[] args) {
Employe e1 = new Employe("Karim", 1000);
Employe e2 = new Employe("Ahmed", 1200);
int i = 10;
m(i, e1, e2);
System.out.println(i + '\t' + e1.salaire+ '\t' + e2.nom);
}

Que sera-t-il affiché ?
Rep: 10
800
Ahmed
76
Exemple de passage de paramètres
main()
Employe e1 = new Employe("Karim",
1000); Employe e2 = new Employe(«
Ahmed", 1200); int i = 10;
i
10
e1
e2
Pile
Karim
1000
Ahmed
1200
Tas
77
Exemple de passage de paramètres
main():
m(i,e1,e2)
ip
m
e1p
10
i
10
e2p
Karim
1000
e1
Ahmed
1200
e2
Pile
Tas
78
Exemple de passage de paramètres
m():
ip = 100;
e1p.salaire = 800;
e2p = new Employe("Ali", 900);
ip
m
e1p
100
i
10
e2p
Karim
1000
e1
Ahmed
1200
e2
Pile
Tas
79
Exemple de passage de paramètres
m():
ip = 100;
e1p.salaire = 800;
e2p = new Employe("Ali", 900);
ip
m
e1p
100
i
10
e2p
Karim
800
e1
Ahmed
1200
e2
Pile
Tas
80
Exemple de passage de paramètres
m():
ip = 100;
e1p.salaire = 800;
e2p = new Employe("Ali", 900);
ip
m
e1p
100
i
10
e2p
Karim
800
e1
Ahmed
1200
e2
Pile
Tas
81
Exemple de passage de paramètres
m():
ip = 100;
e1p.salaire = 800;
e2p = new Employe("Ali", 900);
ip
m
e1p
100
i
10
e2p
Karim
800
e1
Ahmed
1200
e2
Pile
Tas
82
Exemple de passage de paramètres
m():
ip = 100;
e1p.salaire = 800;
e2p = new Employe("Ali", 900);
ip
m
e1p
Ali
100
i
10
e2p
Karim
800
e1
Ahmed
1200
e2
Pile
Tas
83
Exemple de passage de paramètres
Main():
System.out.println(i + '\n' + e1.salaire+ '\n' + e2.nom);
Ali
m
Karim
800
i
10
e1
Ahmed
1200
e2
Pile
Tas
84
Paramètre final
final indique que le paramètre ne pourra
être modifié dans la méthode
 Si le paramètre est d’un type primitif, la
valeur du paramètre ne pourra être modifiée
:
int m(final int x)
 Attention ! si le paramètre n’est pas d’un
type primitif, la référence à l’objet ne pourra
être modifiée mais l'objet lui-même pourra
l'être :
int m(final Employe e1)

Le salaire de l’employé
e1 pourra être modifié
85
Nombre variable d’arguments



Quelquefois il peut être commode d’écrire
une méthode avec un nombre variable
d’arguments
L’exemple typique est la méthode printf
du langage C qui affiche des arguments
selon un format d’affichage donné en
premier argument
Depuis le JDK 5.0, c’est possible en Java
86
Syntaxe pour arguments variables


A la suite du type du dernier paramètre on
peut mettre « ... » :
Exemple
String...
Object...
int...
87
Traduction du compilateur
Le compilateur traduit ce type spécial par un
type tableau ie m(int p1, String... params)

est traduit par
m(int p1, String[] params)
Le code de la méthode peut utiliser params
comme si c’était un tableau (boucle for,
affectation, etc.)

88
Récursivité des méthodes
Les méthodes sont récursives ; elles peuvent
s’appeler elles-mêmes :
static long factorielle(int n) {
if (n == 0)
return 1;
else
return n * factorielle(n - 1);
}
89
Exercices
class Circle{
public double x, y;
// Coordonnée du centre
private double r;
// rayon du cercle
public Circle(double r) {
//Section manquante
this.r = r;
}
public double area() {
return Math.PI* r * r;
}
}
public class MonPremierProgramme {
public static void main(String[] args) {
Circle c;
// c est une référence sur un objet Circle, pas un objet
c = new Circle(5.0); // c référence maintenant un objet alloué en mémoire
c.x = c.y = 10;
System.out.println("Aire de c :" + c.area());
}
90
Exercice
class Compte{
private String nom;
private double solde;
private int num; public static int nbreComptes=0;
public String adresse;
public void virer(Compte c, double s)
public Compte (String n, int nu, String ad) {
this.solde = 0;
{
this.nom = n;
if (solde >=s) {this.solde -= s;
this.num = nu;
c.solde=c.solde+s;
adresse=ad; nbreComptes++;
}
}
public Compte () {
else System.out.println(" Solde Insuffisant!! ");
nbreComptes++;
}
}
} // fin de la classe
public void verser(double s) {
this.solde += s;
}
public void afficher() {
System.out.println("NOM :" + this.nom);
System.out.println("NUMERO :" + this.num);
System.out.println(:" SOLDE:" + this.solde);
}
public class Banque {
public static void main(String[] args) {
Compte c;
c = new Compte() ;
c.verser(1000.0); Compte b =new Compte (" rachid ", 111, " Tetouan " );
c.afficher(); c.virer(b,2000); b.afficher();
System.out.println(" Nbre de compte:" + Compte.nbreComptes); }
}
91
Héritage
92
Héritage
Définition
Le terme héritage désigne le principe selon lequel une classe
peut hériter des caractéristiques (attributs et méthodes)
d’autres classes.
Pour raccourcir les temps d’écriture et de mise au point du
code d’une application, il est intéressant de pouvoir réutiliser
du code déjà écrit.
Exemple : Héritage, Agrégation ou Utilisation
)
Salle de bains et Baignoire ?
)
Piano et Joueur de piano ?
)
Personne, Enseignant et Étudiant ?
93
Réutilisation par l'héritage
L’héritage existe dans tous les langages objet à
classes
 L’héritage permet d’écrire une classe B
– qui se comporte dans les grandes lignes comme la
classe A
– mais avec quelques différences sans toucher au
code source de A
 On a seulement besoin du code compilé de A

94
Réutilisation par l'héritage


Le code source de B ne comporte que ce qui a
changé par rapport au code de A
On peut par exemple
– ajouter de nouvelles méthodes
– modifier certaines méthodes
95
Vocabulaire


La classe A s'appelle une classe mère, classe
parente ou super-classe
La classe B qui hérite de la classe A s'appelle une
classe fille ou sous-classe
96
Exemple d’héritage en Java - classe mère
public class Personne {
private String Nom, Prenom; //
private int age;
// La classe contient des constructeurs,
// des méthodes getNom(), setNom(String )
// getPrenom(), getAge(),
// setPrenom(String), setAge(int),
...
public void Afficher ()
{ System.out.println(‘’nom : ‘’+Nom+‘’ Prenom : ‘’+Prenom+‘’Age : ‘’+Age);
}
}
97
Exemple d’héritage en Java - classe fille
public class Etudiant extends Personne {
private int cne; // nouvelle variable
// Constructeurs
...
// Nouvelles Méthodes
public getCne() { return this.cne; }
public setCne(int Cne) { this.cne= Cne; }
// Méthodes modifiées
public void Afficher() {
Super.Afficher();
System.out.println(‘’ CNE: ‘’+cne);
}
}
98
Redéfinition et surcharge
Ne pas confondre redéfinition et surcharge des
méthodes :
–on redéfinit une méthode quand une nouvelle
méthode a la même signature qu’une méthode héritée de la
classe mère
–on surcharge une méthode quand une nouvelle méthode a le
même nom, mais pas la même signature, qu’une autre méthode
de la même classe
Rappel: Signature d’une méthode (nom de la méthode +
ensemble des types de ses paramètres)

99
L’héritage en Java
En Java, chaque classe a une et une seule classe
mère (pas d’héritage multiple) dont elle hérite les
variables et les méthodes

Le mot clef extends indique la classe mère :
class Etudiant extends Personne
Par défaut (pas de extends dans la définition
d’une classe), une classe hérite de la classe Object

100
Ce que peut faire une classe fille
La classe qui hérite peut
–ajouter des variables,
constructeurs
des
méthodes
et
des
–redéfinir des méthodes (exactement les mêmes types
de paramètres)
–surcharger des méthodes (même nom mais pas même
signature) (possible aussi à l’intérieur d’une classe)
101
Principe important lié à la notion d’héritage


Si « B extends A », le grand principe est que tout B
est un A
Par exemple, un étudiant est une personne; un
poisson est un animal ; une voiture est un
véhicule
102
Sous-type
B est un sous-type de A si on peut ranger une expression de
type B dans une variable de type A
 Les sous-classes d’une classe A sont des sous types de A
 En effet, si B hérite de A, tout B est un A donc on
peut ranger un B dans une variable de type A
 Par exemple,
A a = new B(…); est autorisé

103
L’héritage en notation UML
104
1ère instruction d’un constructeur
La première instruction (interdit de placer cet
appel ailleurs !) d’un constructeur peut être un appel

–à un constructeur de la classe mère :
super(...)
–ou à un autre constructeur de la classe :
this(...)
105
Appel implicite du constructeur de la classe mère
Si la première instruction d'un constructeur
n'est ni super(...), ni this(...), le compilateur ajoute un
appel implicite au constructeur sans paramètre de la
classe mère (erreur s’il n’existe pas)
=> Un constructeur de la classe mère est toujours
exécuté avant les autres instructions du constructeur

106
Exemple sur les constructeurs
Question: Quel est le résultat?
ABC
Attention: Le compilateur ajoute
par défaut le mot super au début
des constructeurs des classes
filles
107
Exemple sur les constructeurs








public class Cercle {
// Constante
public static final double PI = 3.14;
// Variables
private Point centre; private int rayon;
// Constructeur
public Cercle(Point c, int r) {
centre = c;
rayon = r;
}
Ici pas de constructeur sans
paramètre
}
108
Exemple sur les constructeurs
public class CercleColore extends Cercle {
private String couleur;
public CercleColore(Point p, int r, String c) {
super(p, r);
Que se passe-t-il si on enlève
couleur = c;
cette instruction?
}
public void setCouleur(String c) {
couleur = c;
}
public String getCouleur() {
return couleur;
}
}
109
Héritage et encapsulation
Les membres déclarés privés dans une classe :
› appartiennent aux sous-classes
›
mais ne sont pas visibles depuis les sous-classes
En d’autres termes :
visibilité
l’héritage n’implique pas la
public class Homme extends Mammifère {
// attributs propres aux hommes uniquement
Private boolean droitier;
Public Homme( String unNom,boolean droitier){
this.setNbVertebres(50);
this.droitier = droitier; this.nom = unNom; // erreur
}
}
110
La visibilité en Java
public
private
111
La visibilité en Java
On peut étendre la visibilité aux sous-classes avec le mot clé : proctected.
public
protected
private
112
La visibilité en Java
On peut étendre la visibilité aux sous-classes avec le mot clé : proctected.
Attention : on n’étend pas la visibilité private mais la visibilité par défaut.
⇒ l’héritage s’ajoute aux packages
⇒ protected ne protège pas mais augmente la visibilité !

public


protected


défaut



private
113
La visibilité en Java
On peut étendre la visibilité aux sous-classes avec le mot clé :
proctected.
Attention : on n’étend pas la visibilité private mais la visibilité par
défaut.
=⇒ l’héritage s’ajoute aux packages
=⇒ protected ne protège pas mais augmente la visibilité !
la classe elle-même
private
OUI
défaut
OUI
protected
OUI
public
OUI
une sous-classe, paquetage =
NON
OUI
OUI
OUI
pas une sous-classe, paquetage =
NON
OUI
OUI
OUI
une sous-classe, paquetage différent NON
NON
OUI
OUI
pas une sous-classe, paquetage diff NON
NON
NON
114
OUI
Héritage – problème d’accès
public class Animal {
private String nom;
public Animal() {
}
public Animal(String unNom) {
nom = unNom;
}
public void setNom(String unNom) { nom = unNom;
}
public String getNom() {
return nom ;
}
public String toString() {
return "Animal " + nom; }
115
}
Héritage – problème d’accès
public class Poisson extends Animal {
private int profondeurMax;
public Poisson(String nom, int uneProfondeur) {
super(nom); // cette instruction est-elle correcte ?
profondeurMax = uneProfondeur;
}
public void setProfondeurMax(int uneProfondeur) {
profondeurMax = uneProfondeur;
}
public String toString() {
return "Poisson " + getNom() + " ; plonge jusqu’à "
+ profondeurMax + " mètres";
}
}
116
De quoi hérite une classe ?
Si une classe B hérite de A (B extends A), elle hérite
automatiquement et implicitement de
tous les membres de la classe A (mais pas des
constructeurs)
Cependant la classe B peut ne pas avoir accès à certains
membres dont elle a implicitement
hérité de A (par exemple, les membres private)
B donc ne peut pas les nommer ni les utiliser explicitement

117
Redéfinition des méthodes
Soit une classe B qui hérite d'une classe A
Dans une méthode d'instance m() de B, super.
sert à désigner un membre de A :

– en particulier, super.m()désigne la méthode de
A qui est donc en train d’être redéfinie dans B :
int m(int i) {
return 500 + super.m(i);
}
118
Redéfinition des méthodes

On ne peut trouver super.m() dans une
méthode static m() ;
Attention !!!
une méthode static ne peut être redéfinie
119
Accès protected
protected joue sur l’accessibilité des
membres (variables ou méthodes) par les classes filles
 Un membre protected de la classe A peut être
manipulé par les classes filles de A sans que les
autres classes non filles de A ne puisse les
manipuler

120
Exemple
public class Animal {
protected String nom;
...
}
public class Poisson extends Animal { private int
profondeurMax;
public Poisson(String unNom, int uneProfondeur) {
nom = unNom; // utilisation de nom de la classe mère
profondeurMax = uneProfondeur;
}
121
Polymorphisme
Contexte: soit B hérite de A et que la méthode
m() de A soit redéfinie dans B

Quelle méthode m() sera exécutée dans le code suivant,
celle de A ou celle de B ?




A a = new B(5);
a.m();
a est un objet de la classe B
mais il est déclaré de la classe A
La méthode appelée ne dépend que du type réel (B) de
l’objet a (et pas du type déclaré, ici A).

C’est la méthode de la classe B qui sera exécutée
122
Polymorphisme

Le polymorphisme est le fait qu’une même écriture peut
correspondre à différents appels de méthodes ; par
exemple,


A a = x.f();
a.m();
appelle la méthode m() de A ou de n’importe quelle sousclasse de A
f peut renvoyer une instance de A
ou de n’importe quelle sousclasse de A
Ce concept est une notion fondamentale de la
programmation objet, indispensable pour une
utilisation efficace de l’héritage

123
Mécanisme du polymorphisme
Le polymorphisme est obtenu grâce au « late
binding » (liaison retardée) : la méthode qui sera
exécutée est déterminée

–seulement à l’exécution, et pas dès la compilation
–par le type réel de l’objet qui reçoit le message (et
pas par son type déclaré)
124
Utilisation du polymorphisme

Le polymorphisme facilite l’extension des programmes :
 on
peut créer de nouvelles sous-classes sans toucher aux programmes déjà
écrits
Par exemple, si on ajoute une classe Enseignant, le code de
Afficher() sera toujours valable
 Sans polymorphisme, il aurait fallu modifier le code source de
la classe Personne.

125
Exercice
126
Exercice
Donnez les résultats des bouts de code suivants:
127
Exercice
Donnez les résultats des bouts de code suivants:
128
Modificateur final
Classe final : ne peut avoir de classes filles (String
est final)
Méthode final : ne peut être redéfinie
Variable (locale ou d’état) final : la valeur ne
pourra être modifiée après son initialisation
Paramètre final (d’une méthode ou d’un catch) : la
valeur (éventuellement une référence) ne pourra être
modifiée dans le code de la méthode

129
CLASSES ABSTRAITES
130
Méthodes abstraites


Une méthode est abstraite (modificateur abstract)
lorsqu’on la déclare, sans donner son implémentation
La méthode sera implémentée par les classes filles
131
Classes abstraites
Une classe doit être déclarée abstraite
(abstract class) si elle contient une méthode abstraite


Il est interdit de créer une instance d’une classe
abstraite
132
Classes abstraites
Si on veut empêcher la création d’instances
d’une classe on peut la déclarer abstraite même
si aucune de ses méthodes n’est abstraite

Une méthode static ne peut être abstraite (car
on ne peut redéfinir une méthode static)

133
Classes abstraites

Certaines classes ne doivent tout
simplement pas être instanciées

Exemple Animal

Que signifie un objet de type FormGeométrique?

Animal anim = new Animal();
 Quelle est sa forme? Sa taille? Sa couleur?...
134
Classe Object
En Java, la racine de l’arbre d’héritage des classes
est la classe java.lang.Object
La classe Object n’a pas de variable d’instance ni de
variable de classe
La classe Object fournit plusieurs méthodes
qui sont héritées par toutes les classes sans
Exception:

 les
plus couramment utilisées sont les méthodes toString() et
equals()
135
Définition des interfaces


Une interface est une « classe » purement abstraite
dont toutes les méthodes sont abstraites et
publiques
C’est une liste de noms de méthodes publiques
136
Exemples
public interface Figure {
public abstract void dessineToi();
public abstract void deplaceToi(int x, int y);
public abstract Position getPosition();
}
public interface Comparable {
/** renvoie vrai si this est plus grand que o */
int compareTo(Object o);
}
137
Les interfaces sont implémentées par des classes

Une classe implémente une interface I si elle
déclare « implements I » dans son en-tête
138
Exemple d’implémentation
public class Ville implements Comparable {
private String nom;
private int nbHabitants;
Exactement la même signature
...
que dans l’interface Comparable
public int compareTo(Object objet) {
if (objet instanceof Ville) {
return nbHabitants > ((Ville)objet).nbHabitants;
}
else {
throw new IllegalArgumentException();
}
}
}
139
Classe qui implémente partiellement une interface

Soit une interface I1 et une classe C qui l’implémente :
public class C implements I1 { … }
C peut ne pas implémenter toutes les
méthodes de I1

Mais dans ce cas C doit être déclarée
abstract (il lui manque des implémentations)

Les méthodes manquantes seront implémentées par
les classes filles de C
140
Classe qui implémente partiellement une interface


Une classe peut implémenter une ou plusieurs
interfaces (et hériter d'une classe…) :
public class CercleColore extends Cercle
implements Figure, Coloriable {
141
Contenu des interfaces

Une interface ne peut contenir que
– des méthodes abstract et public
– des définitions de constantes publiques (« public static final
»)
Les modificateurs public, abstract et final
sont optionnels (en ce cas, ils sont implicites)
 Une interface ne peut contenir de méthodes static,
final

142
Accessibilité des interfaces



Une interface peut avoir la même accessibilité que
les classes :
–public : utilisable de partout
– sinon : utilisable seulement dans le même
paquetage
143
Les interfaces comme types de données


Une interface peut servir à déclarer une variable,
un paramètre, une valeur retour, un type de base
de tableau, un cast,…
Par exemple,Comparable v1; indique que la
variable v1 référencera des objets dont la classe
implémentera l’interface Comparable
144
Interfaces et typage

Si une classe C implémente une interface I,
le type C est un sous-type du type I :
 tout C peut être considéré comme un I



On peut ainsi affecter une expression de type C à
une variable de type I
Les interfaces « s’héritent » : si une classe C
implémente une interface I, toutes les sous classes de
C l’implémentent aussi (elles sont des sous-types de I)
145
Exemple d’interface comme type de données
public static boolean croissant(Comparable[] t) {
for (int i = 0; i < t.length - 1; i++) {
if (t[i].compareTo(t[i + 1]))
return false;
}
return true;
}
146
instanceof

Si un objet o est une instance d’une classe qui
implémente une interface Interface,
o
instanceof Interface est vrai
147
Polymorphisme et interfaces
public interface Figure { void dessineToi();
}
public class Rectangle implements Figure {
public void dessineToi() {
...
}
public class Cercle implements Figure {
public void dessineToi() {
...
}
148
Polymorphisme et interfaces (suite)
public class Dessin { private
Figure[] figures;
...
public void afficheToi() {
for (int i=0; i < nbFigures; i++)
figures[i].dessineToi();
}
...
}
149
Exemple Interface Comparable

Contient la méthode nécessaire pour comparer deux objets:


Objectif: Définir un ordre naturel sur des objets
Public interface Comparable {
Public int compareTo (Object o);
}
 La méthode retourne un integer négatif si


this est plus petit que o, 0 si les deux objets sont égaux ou positif sinon.
Une classe qui implante l’interface Comparable peut utiliser la
méthode: exple la classe Arrays
150
Exemple Interface Comparable
On peut toujours faire des casts (upcast et downcast) entre une
classe et une interface qu’elle implémente (et un upcast entre une
interface et la classe Object) :
// upcast Ville → Comparable
Comparable c1 = new Ville("Cannes", 200000); Comparable
c2 = new Ville("Nice", 500000);
...
if (c1.pcompareTo(c2)) // upcast Comparable → Object
// downcast Comparable → Ville
System.out.println(((Ville)c2).nbHabitant());

151
Dérivation d’interface
On peut définir une interface comme une généralisation d’une autre
interface X{
...}
interface Y{
...}
interface Z{
...}
interface A extends X {
...}
interface B extends X, Y, Z {
...}


La dérivation revient simplement à concaténer des déclarations
152
Dérivation d’interface
interface A { int info = 1;
}
interface B {
int info = 1;
}
public class C implements A, B{
public void f() {
System.out.println(A.info);
System.out.println(B.info);
}
public static void main (String args[])
{
C c = new C(); c.f();
}
}
Qu’affiche ce programme?
153
Interface
Important for interface:
1) Look for interface definitions that define constants,
but without explicitly using the required modifiers.
For example, the following are all identical:
public int x = 1; // Looks non-static and non-final,
but isn't!
int x = 1;
// Looks default, non-final,
non-static, but
isn't!
Dérivation
d’interface
static int x = 1;
// Doesn't show final or public
final int x = 1;
// Doesn't show static or
public
public static int x = 1;
// Doesn't show final
public final int x = 1;
// Doesn't show static
static final int x = 1
// Doesn't show public
public static final int x = 1; // what you get
implicitly
154
Interface
Any
combination
of
the
modifiers is legal,
all! On the exam,
required
(but
implicit)
as is using no modifiers at
you can expect to see questions
you won’t Dérivation
be able to answer
correctly unless you
d’interface
know,
final
for example,
and
can
never
that an interface variable is
be
given
a
value
by
implementing (or any other) class.
155
the
Interface
2) Look for illegal uses of extends and implements. The following
shows examples of legal and illegal class and interface declarations:
class Foo { }
// OK
class Bar implements Foo { }
// No! Can't implement a class
interface Baz { }
// OK
interface Fi { }
// OK
interface Fee implements Baz { }
// No! Interface can't
implement
an interface
interface Zee implements Foo { }
// No! Interface can't implement a
class
interface Zoo extends Foo { }
// No! Interface can't
extend a
class
interface Boo extends Fi { }
// OK. Interface can extend
an
interface
class Toon extends Foo, Button { } // No! Class can't extend multiple
classes
class Zoom implements Fi, Baz { } // OK. class can implement
multiple interfaces
interface Vroom extends Fi, Baz { } // OK. interface can extend
multiple interfaces
156
class Yow extends Foo implements Fi { } // OK. Class can do both
(extends must be 1st)
Exercice
Supposons que l'on veuille écrire un programme de gestion de ressources humaines
d’un établissement universitaire s'occupant du personnel. Tout membre du personnel
a un bureau. Dans le personnel, on distingue les administratifs et les enseignants.
Chaque personnel a un nom et reçoit un salaire à la fin du mois. les enseignants
reçoivent une somme pour les heures supplémentaires accomplies. La classe
enseignant
possède, hormis des attributs hérités de la classe Personnel, un
attribut Grade.
Attention, la classe Personnel ne correspond en réalité à aucun objet existant, elle ne
fait que rassembler les caractéristiques communes à tous les objets
manipulés par l'application, qui seront des
réellement
instances des classes Enseignant et
Administratif que vous allez définir par la suite.
Une conséquence de ceci, est que la méthode Calculer_Salaire() de la
classe Personnel n'a aucune définition, elle sera définie effectivement dans les sous157
classes.
Questions :
1) Développer la classe Personnel, la classe doit avoir un constructeur par
défaut, constructeur surchargé, une méthode Afficher() et la méthode
Calculer_Salaire().
2) Développer la classe Enseignant et Adminitratif en profitant de
l’héritage
et
redéfinissez
les
méthodes :
Afficher()
et
Calculer_Salaire().
3) Ecrire une classe GestionRH contenant une liste de personnel
List_Pers et trois méthodes.
 void Ajouter( Personnel p) : permettant d’ajouter un personnel(
enseignant ou administratif) à la liste du personnel
 void Afficher() : qui tout le personnel stocké dans la liste
 void Afficher_Enseignant() : qui affiche que les enseignants.
4) Créer un programme Test pour tester les classes développées.
158