Chapitre 1

Présentation de JAVA

[Link]@[Link]
ENSI II1
Vu Pham 397

397

Java c'est quoi ?

 Langage de programmation orienté objet présenté en 1995 par

James Gosling et Patrick Naughton employés par Sun
Microsystems avec le soutien de Bill Joy.
 Apparition de la version 1.2 en 1998 qui a apporté de
nombreuses améliorations et fonctionnalités :
 Java 2 Standard Edition (J2SE)

 Java 2 Entreprise Edition (J2EE)

 2000-2014 : plusieurs versions sont apparues

 2010 : Sun a été rachetée par Oracle

ENSI II1
Vu Pham 398

398
 Java c'est quoi ?

Les différentes versions de Java :

Java SE Java SE Java SE

Java 1.0 Java 1.1 Java 1.2 J2SE 1.3 J2SE 1.4 J2SE 5.0
6 7 8
Nombre
de 8 23 59 76 135 166 202 209 217
packages

ENSI II1
Vu Pham 399

399

Objectifs

 La Portabilité
 L’élimination de la gestion manuelle de
l’allocation dynamique, les pointeurs et
l’héritage multiple.
 Combler les lacunes de sécurité et l’absence de
ramasse-miettes, etc.

ENSI II1
Vu Pham 400

400
 Java et la portabilité

ENSI II1
Vu Pham 401

401

Java et la portabilité

 Avec JAVA, le code source n’est pas traduit directement dans le

langage de l’ordinateur.

 Il est d’abord traduit dans un langage appelé « bytecode », langage

d’une machine virtuelle (JVM ; Java Virtual Machine) définie par
Sun.

 Ce langage est indépendant de l’ordinateur qui va exécuter le

programme.

ENSI II1
Vu Pham 402

402
 Java et la portabilité

Programme source
Programme Java [Link]

Compilateur: javac
compilateur

Programme en bytecode,
indépendant de l'ordinateur Bytecode
[Link]

ENSI II1
Vu Pham 403

403

Structure d’un programme Java

Exemple de programme Java :

public class MonProgramme
{
public static void main (String args[])
{
[Link] ("Mo programme Java");
}
}

Le mot-clé public dans public class MonProgramme sert à définir les

droits d’accès des autres classes à la classe MonProgramme.

ENSI II1
Vu Pham 404

404
 Structure d’un programme Java

 Le mot-clé static précise que la méthode main n’est pas liée à une
instance particulière de la classe.

 Le mot-clé public dans public static void main est obligatoire pour
que le programme puisse s’exécuter. Ici, il s’agit d’une convention
qui permet à la machine virtuelle d’accéder à la méthode main.

NB: On peut inverser l’ordre des mots- clés public et static en

écrivant static public void main.

ENSI II1
Vu Pham 405

405

Structure d’un programme Java

 Le paramètre String[] args de la fonction main permet de

récupérer des arguments transmis au programme au moment de
son lancement. On peut lancer un programme sans fournir
d’arguments, mais l’indication String args[] est obligatoire.

 String[] args  String args[]

 Le nom d’une classe commence toujours par une majuscule, il est

nécessaire de définir le nom du fichier selon le même principe
sinon la classe risque de ne pas compiler.

ENSI II1
Vu Pham 406

406
 Structure 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

ENSI II1
Vu Pham 407

407

Types élémentaires
 En Java, toute variable appartenant à un objet (définie comme
étant un attribut de l'objet) est initialisée avec une valeur par
défaut au moment de la création.
 Cette initialisation ne s'applique pas aux variables locales des
méthodes de la classe.
 Les valeurs par défaut lors de l'initialisation automatique des
variables d'instances sont :
Type Valeur par défaut
Boolean false
byte, short, int, long 0
float, double 0.0
char \u0000
classe null

ENSI II1
Vu Pham 408

408
 Flottants en Java

 En Java, aucune opération sur les flottants ne conduit à un arrêt

de l’exécution (pas même une division par zéro !).

 En effet, les flottants sont codés en respectant les conventions

IEEE 754 qui incluent les trois constantes suivantes :
 indéfini : [Link] ou [Link] (not a number)
 indéfini positif : Float.POSITIVE_INFINITY ou Double.POSITIVE_INFINITY
 indéfini négatif : Float.NEGATIVE_INFINITY ou Double.NEGATIVE_INFINITY

 En Java, ces valeurs peuvent même être affichées ou affectées

directement à des variables.

ENSI II1
Vu Pham 409

409

Flottants en Java

public class IEEE

{ public static void main (String args[])
{ float x = 1e30f ;
float y ;
y = x*x ;
[Link] (x + " a pour carre : " + y) ;
float zero = 0.f ; // division flottante par zero
float z = y/zero ;
[Link] (y + " divise par 0 = " + z) ;
y = 15 ;
[Link] (y + " divise par 0 = " + z) ;
float x1 = Float.POSITIVE_INFINITY ; // +infini
float x2 = Float.NEGATIVE_INFINITY ; // -infini
z = x1/x2 ;
[Link] (x1 + "/" + x2 + " = " + z) ;
}
}

ENSI II1
Vu Pham 410

410
 Flottants en Java

1.0E30 a pour carre : Infinity

Infinity divise par 0 = Infinity
15.0 divise par 0 = Infinity
Infinity/-Infinity = NaN

ENSI II1
Vu Pham 411

411

Conversion de types

 Une conversion telle que int  float est une conversion

d’ajustement de type.
 Elle ne peut se faire que suivant une hiérarchie qui permet de
préserver la valeur initiale : int  long  float  double

 Conformément à cette hiérarchie, on peut bien sûr convertir

directement un int en double ; mais on ne pourra pas convertir un
double en float ou en int.

ENSI II1
Vu Pham 412

412
 Conversion de types

 Les opérateurs numériques ne sont pas définis pour les types

byte, char et short.

 Java prévoit que toute valeur de l’un de ces deux types

apparaissant dans une expression soit d’abord convertie en int, et
cela sans considérer les types des éventuels autres opérandes.

 On parle alors de promotions numériques (ou encore de

conversions systématiques).

ENSI II1
Vu Pham 413

413

Conversion de types

 Les opérandes et le résultat de l'opération sont convertis

en type int.
short x=5, y=15;
x=x+y; // erreur à la compilation

 Le résultat est affecté dans un type short : il y a donc risque

de perte d'informations et donc une erreur est émise à la
compilation.
 Pour régler le problème, il est nécessaire d'utiliser une
conversion explicite ou cast.
x=(short)(x+y);

ENSI II1
Vu Pham 414

414
 Conversion de types

Le programmeur peut forcer la conversion d’une expression

quelconque dans un type de son choix, à l’aide du cast.

double x;
(int) x;

ENSI II1
Vu Pham 415

415

Chapitre 2
Les classes

[Link]@[Link]
ENSI II1
Vu Pham 416

416
 Déclaration de classes

 Une classe est un ensemble de données et de fonctions

regroupées dans une même entité.

 La syntaxe de déclaration d'une classe est la suivante :

modificateurs class nom_de_classe
{ ... }

 En C++, on distingue la déclaration d’une classe de sa définition.

Généralement, la première figure dans un fichier en-tête, la
seconde dans un fichier source. Cette distinction n’existe pas en
Java.

ENSI II1
Vu Pham 417

417

Déclaration de classes

Modificateurs :
 Ils s'appliquent aux classes, aux méthodes et aux attributs.

 Ils ne peuvent pas être utilisés pour qualifier des variables

locales : seules les variables d'instances et de classes peuvent
en profiter.

 Ils assurent le contrôle des conditions d'héritage, d'accès aux

éléments et de modification de données par les autres objets.

ENSI II1
Vu Pham 418

418
 Visibilités en JAVA

Visibilité Rôle
public visible par tous les autres objets.
par
défaut:
visible par toutes les classes se trouvant dans le même package.
package
friendly

visible par les méthodes présentes dans le même package que cette classe
protected ou ses sous-classes pourront y accéder.
On ne peut pas qualifier une classe avec protected.

visible par les méthodes définies dans la classe et prévues à cet effet.
NB: Les méthodes déclarées private ne peuvent pas être en même temps
private
déclarées abstract car elles ne peuvent pas être redéfinies dans les classes
filles.

ENSI II1
Vu Pham 419

419

Mots-clés en JAVA

Mot-clé Signification
static s'applique aux variables d’instances et aux méthodes partagées entre toutes les
instances
final Le mot clé final s'applique aux variables, aux méthodes, aux paramètres d'une
méthode et aux classes.
Il permet de rendre l'entité sur laquelle il s'applique non modifiable une fois
qu'elle est déclarée.
Une fois la variable déclarée final initialisée, il n'est plus possible de modifier sa
valeur.
abstract Le mot clé abstract s'applique aux méthodes et aux classes.
abstract indique que la classe ne pourra être instanciée telle quelle. Toutes les
méthodes abstract de cette classe devront être redéfinies dans ses sous-classes.
Une classe est automatiquement abstraite dès qu'une de ses méthodes est
déclarée abstraite. Il est possible de définir une classe abstraite sans méthodes
abstraites.

ENSI II1
Vu Pham 420

420
Déclaration de classes

public class Point

{ public Point(int abs, int ord)
{ x = abs ;
y = ord ;
}
public void deplace (int dx, int dy)
{ x += dx ;
y += dy ;
}
public void affiche ()
{ [Link] ("Je suis un point de coordonnees
" + x + " " + y) ;
}
private int x ; // abscisse
private int y ; // ordonnee
}
ENSI II1
Vu Pham 421

421

Construction/destruction d’objets

Instanciation de la classe Point

Point a;
a = new Point(2,3) ;
// crée un objet de type Point et place sa référence dans a
[Link]();
….

a 3

ENSI II1
Vu Pham 422

422
 Construction/destruction d’objets

La durée de vie d'un objet passe par trois étapes :

 La déclaration de l'objet et l'instanciation grâce à l'opérateur
new ;
 L'utilisation de l'objet en appelant ses méthodes ;

 La suppression de l'objet qui est automatique en Java: il

n'existe pas d'instruction delete comme en C++.

ENSI II1
Vu Pham 423

423

Les constructeurs
L'appel de new pour créer un nouvel objet déclenche, dans l'ordre :
L'allocation mémoire nécessaire au stockage de ce nouvel objet et
l'initialisation par défaut de ces attributs,
L'initialisation explicite des attributs, s'il y a lieu,
L'exécution d'un constructeur.
Un constructeur est une méthode d'initialisation.

public class Application

Le constructeur est ici celui
{
par défaut (pas de
public static void main(String args[])
constructeur défini dans
{
la classe Personne)
Personne jean = new Personne()
[Link]("Jean") ;
} }

ENSI II1
Vu Pham 424

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

ENSI II1
Vu Pham 425

425

Construction/destruction d’objets

Java emploie un mécanisme de gestion automatique de la mémoire

connu sous le nom de ramassse-miettes (en anglais Garbage
Collector).

ENSI II1
Vu Pham 426

426
 Le mot-clé this
this permet de désigner l’objet courant,
 this permet d'accéder aux attributs et méthodes de l’objet
courant.

 Pour manipuler un attribut de l’objet courant: [Link]

 Pour manipuler une méthode : [Link] ( )

 Pour faire appel au constructeur de l’objet courant: this()

ENSI II1
Vu Pham 427

427

Manipulation des références

class Circle {
private double x, y; // coordonnées du centre
private double r; // rayon du cercle
public Circle(double r) {
this.r = r;
}
public Circle(double a, double b, double c) {
x = a; y = b; r = c;
}
}
// soient les instructions suivantes dans la méthode main
par exp :
Circle c1, c2;
c1 = new Circle(2.0, 3.0, 4.0);
c2 = new Circle(2.0);
c1 = c2;
// c2 et c1 pointent vers le même objet

ENSI II1
Vu Pham 428

428
 Manipulation des références

Que faire du premier objet?

Aucune référence ne pointe vers lui
L’objet est perdu et inutilisable
Le ramasse miette (garbage collector) va récupérer l’espace
occupé par l’objet

Comparaison des références

(c1 == c2): est-ce que c1 et c2 pointent vers le même objet?

Comparaison des objets

Méthode equals() héritée de la classe Object [Link](c2);

ENSI II1
Vu Pham 429

429

Manipulation des références

 Le littéral null est utilisable partout où il est possible d'utiliser

une référence à un objet.

 Il n'appartient pas à une classe mais il peut être utilisé à la place

d'un objet de n'importe quel type ou comme paramètre.

 Le fait d'affecter null une variable référençant un objet pourra

permettre au ramasse-miettes de libérer la mémoire allouée à
l'objet si aucune autre référence n'existe encore sur lui.

ENSI II1
Vu Pham 430

430
 Manipulation des références

La variable this sert à référencer dans une méthode l'instance de

l'objet en cours d'utilisation.

private int nombre;

public maclasse(int nombre) {
[Link] = nombre;
// variable de classe = variable en paramètre du constructeur
}

ENSI II1
Vu Pham 431

431

Tableaux

 Ce sont des objets : ils sont donc dérivés de la classe Object.

 Java permet de placer les crochets après ou avant le nom du

tableau dans la déclaration.

int tab[] = new int[50]; // déclaration et allocation

OU int[] tab = new int[50];

OU int tab[]; // déclaration

tab = new int[50]; //allocation

ENSI II1
Vu Pham 432

432
 Tableaux

Java ne supporte pas directement les tableaux à plusieurs

dimensions : il faut déclarer un tableau de tableau.

float tableau[][] = new float[10][10];

La taille des tableaux de la seconde dimension peut ne pas être

identique pour chaque occurrence.
int dim1[][] = new int[3][];
dim1[0] = new int[4];
dim1[1] = new int[9];
dim1[2] = new int[2];

ENSI II1
Vu Pham 433

433

Tableaux

Chaque élément du tableau est initialisé selon son type

par l'instruction new :
 0 pour les numériques,
 '\0' pour les caractères,
 false pour les booléens
 null pour les chaines de caractères et les autres objets.

ENSI II1
Vu Pham 434

434
 Tableaux

Initialisation explicite comme en c++

int tableau[] = {10,20,30,40,50};

Le nombre d'éléments de chaque ligne peut ne pas être identique

:
int[][] tabEntiers = {{1,2,3,4,5,6},
{1,2,3,4},
{1,2,3,4,5,6,7,8,9}};

Parcours d’un tableau

for (int i = 0; i < [Link] ; i ++) { ... }

ENSI II1
Vu Pham 435

435

Tableaux
Java permet de manipuler des tableaux, par le biais d’affectations
de leurs références.
Soit l’exemple suivant :
int [] t1 = new int[3] ;
for (int i=0 ; i<3 ; i++) t1[i] = i ;
int [] t2 = new int[2] ;
for (int i=0 ; i<2 ; i++) t2[i] = 10 + i ;

On exécute maintenant l’affectation suivante :

t1 = t2 ;
// la référence contenue dans t2 est recopiée dans t1
//t1 et t2 désignent désormais le même tableau.
[Link] (t1[1]) ;
//donne la valeur 11 et non 1

ENSI II1
Vu Pham 436

436
 Méthodes en Java: modificateurs

 La syntaxe de la déclaration d'une méthode est :

modificateurs type_retourné nom_méthode( arg1, ... ) {... }

 Il n'est pas possible d'indiquer des valeurs par défaut dans les
paramètres.

 Sans modificateur, la méthode peut être appelée par toutes autres

méthodes des classes du package auquel appartient la classe.

ENSI II1
Vu Pham 437

437

Méthodes en Java: le destructeur

 Un destructeur permet d'exécuter du code lors de la libération de

l'espace mémoire occupé par l'objet.

 En Java, les destructeurs appelés finaliseurs (finalizers), sont

automatiquement invoqués par le garbage collector.

 Pour créer un finaliseur, il faut redéfinir la méthode finalize()

héritée de la classe Object.

ENSI II1
Vu Pham 438

438
 Passage de paramètres
 Si un objet o transmet sa variable d'instance v en paramètre à
une méthode m, deux situations sont possibles :
 si v est une variable primitive alors elle est passée par valeur : il est
impossible de la modifier dans m pour que v en retour contiennent
cette nouvelle valeur.
 si v est un objet alors il est passé par référence: m pourra modifier
l'objet en utilisant une méthode de l'objet passé en paramètre.
 Lorsqu'un objet est passé en paramètre, ce n'est pas l'objet lui
même qui est passé mais une référence sur l'objet.
 La référence est bien transmise par valeur et ne peut pas être
modifiée mais l'objet peut être modifié via un message (appel
d'une méthode).
 Pour transmettre des arguments par référence à une méthode, il
faut les encapsuler dans un objet qui prévoit les méthodes
nécessaires pour les mises à jour.

ENSI II1
Vu Pham 439

439

Passage de paramètres
class Util
{ public static void Échange (int a, int b)
{
[Link] ("début Échange : " + a + " " + b) ;
int c ;
c = a ; a = b ; b = c ;
[Link] ("fin Échange : " + a + " " + b) ;
}
}
public class Échange
{ public static void main (String args[])
{
int n = 10, p = 20 ;
[Link] ("avant appel : " + n + " " + p) ;
Util.Échange (n, p) ;
[Link] ("apres appel : " + n + " " + p) ;
}
}

ENSI II1
Vu Pham 440

440
 Passage de paramètres

avant appel : 10 20
debut Échange : 10 20
fin Échange : 20 10
apres appel : 10 20

ENSI II1
Vu Pham 441

441

Passage de paramètres
public class Point {
private int x, y; // coordonnées 2D du points

public Point (int a, int b) {

x=a;
y=b;
Fichier [Link]
}
public static void initPoint (Point p) {
p.x=0;
p.y=0;
}
// Ficher [Link]
public class Main {
public static void main (String[] args){
Point t = new Point(1,2);
[Link]();
[Link](t);
[Link]();
}}}

ENSI II1
Vu Pham 442

442
 Surcharge de méthodes

À la rencontre d’un appel donné, le compilateur recherche toutes les

méthodes acceptables et il choisit la meilleure si elle existe.

Pour qu’une méthode soit acceptable, il faut :

 Qu’elle dispose du nombre d’arguments voulus,
 Que le type de chaque argument effectif soit compatible par
affectation avec le type de l’argument muet correspondant,
 Qu’elle soit accessible (par exemple, une méthode privée sera
acceptable pour un appel depuis l’intérieur de la classe, alors
qu’elle ne le sera pas pour un appel depuis l’extérieur).

ENSI II1
Vu Pham 443

443

Chapitre 3
Classe, héritage et polymorphisme
Classe abstraite et interface

[Link]@[Link]
ENSI II1
Vu Pham 444

444
 Plan
Classe, Objet
Héritage & polymorphisme
Principe général
Polymorphisme
Interdire l'héritage
Utilisation de super
Cas particulier des constructeurs
La classe Object (les méthodes toString et equals)
Classes abstraites & interfaces
Méthode abstraite, classe abstraite
Classe abstraite et polymorphisme
Interface
Interface et polymorphisme
Interface et héritage

ENSI II1
Vu Pham 445

445

Visibilité dans une classe

Modificateur classe paquetage Sous-classe autre

publique oui oui oui oui

protégé oui oui oui non
aucun oui oui non non
privé oui non non non

ENSI II1
Vu Pham 446

446
 Constructeur
Un constructeur n’est rien d’autre qu’une méthode, sans
valeur de retour, portant le même nom que la classe
Il existe un constructeur (pseudo-constructeur) par défaut
Exp: Point p = new Point ();

Il peut être surchargé

Si c’est le cas le constructeur par défaut ne pourra plus être utilisé.

ENSI II1
Vu Pham 447

447

Héritage

Pointcol p2=new Pointcol();

Le pseudo-constructeur de
PointCol va être appelé

ENSI II1
Vu Pham 448

448
 Type de données (entiers) en Java

ENSI II1
Vu Pham 449

449

Construction et héritage

Le constructeur de la classe
dérivée doit prendre en charge
l’intégralité de la construction
de l’objet

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

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

ENSI II1
Vu Pham 450

450
 Remarque : this et super dans le même constructeur?

Il est possible d’appeler dans un constructeur un

autre constructeur de la même classe, en utilisant le
mot-clé this comme nom de méthode.

Comme celui effectué par super, cet appel doit

correspondre à la première instruction du
constructeur.

Dans ces conditions, on voit qu’il n’est pas possible

d’exploiter les deux possibilités en même temps.

ENSI II1
Vu Pham 451

451

Et si la classe de base n’a pas de constructeur?

Cette possibilité s’avère pratique lorsque l’on

définit une classe dérivée sans connaître les
détails de la classe de base.

ENSI II1
Vu Pham 452

452
 Et si la classe dérivée n’a pas de constructeur ?

 Construction de B: Appel au constructeur sans arguments de A

 Construction de B: Erreur de compilation (Pas de constructeur par défaut)

ENSI II1
Vu Pham 453

453

Construction d’un objet B dérivé de la classe A

1. Allocation mémoire pour un objet de type B ; il s’agit bien de
l’intégralité de la mémoire, nécessaire pour un tel objet, et pas
seulement pour les champs propres à B (c’est-à-dire non hérités de A).
2. Initialisation par défaut de tous les champs de B (aussi bien ceux
hérités de A, que ceux propres à B) aux valeurs "nulles" habituelles.
3. Initialisation explicite, s’il y a lieu, des champs hérités de A ;
éventuellement, exécution des blocs d’initialisation de A.
4. Exécution du corps du constructeur de A.
5. Initialisation explicite, s’il y a lieu, des champs propres à
éventuellement, exécution des blocs d’initialisation de B.
6. Exécution du corps du constructeur de B.

ENSI II1
Vu Pham 454

454
 Redéfinition

Un appel récursif
de la méthode affiche()

La méthode
affiche de la
classe Point

ENSI II1
Vu Pham 455

455

Surdéfinition et héritage

La recherche d’une méthode acceptable ne se fait qu’en remontant la hiérarchie

d’héritage

ENSI II1
Vu Pham 456

456
 Polymorphisme
L'héritage définit un cast implicite de la classe
fille vers la classe mère :

 on peut affecter à une référence d'une classe

n'importe quel objet d'une de ses sous-classes.

ENSI II1
Vu Pham 457

457

Polymorphisme: liaison dynamique

Manipuler des objets sans en connaître (tout à fait) le type.

Exploite la relation induite par l’héritage en appliquant la règle
suivante: un objet dérivé est un objet de la classe mère
Concept de liaison dynamique: Appeler la méthode pour
chacun des objets: chaque objet réagira en fonction de son
propre type

ENSI II1
Vu Pham 458

458
 Exemple

ENSI II1
Vu Pham 459

459

Exemple
Aa;Bb;Cc;Dd;Ee;Ff;
les affectations suivantes sont légales :
a = b ; a = c ; a = d ; a = e ; a =f ;
b=d;b=e;
c=f;
En revanche, celles-ci ne le sont pas :
b = a ; // erreur : A ne descend pas de B
d = c ; // erreur : C ne descend pas de D
c = d ; // erreur : D ne descend pas de C

ENSI II1
Vu Pham 460

460
 Exemple
Voici quelques exemples précisant la méthode f
appelée, selon la nature de l’objet effectivement

 Aa
a référence un objet de type A : méthode f de A

a référence un objet de type B : méthode f de A

a référence un objet de type C : méthode f de C

a référence un objet de type D : méthode f de D

a référence un objet de type E : méthode f de A

a référence un objet de type F : méthode f de C.

ENSI II1
Vu Pham 461

461

Attention… liaison dynamique

Malgré son aspect liaison dynamique, le polymorphisme se fonde sur une

signature et un type de retour définis à la compilation (et qui ne seront donc
pas remis en question lors de l’exécution).

ENSI II1
Vu Pham 462

462
 Surdéfinition et héritage

ENSI II1
Vu Pham 463

463

ENSI II1
Vu Pham 464

464
 La super classe Object
Il existe une classe nommée Object dont dérive
implicitement toute classe.
class Point
{ .....

équivaut à
class Point extends Object
{ .....

ENSI II1
Vu Pham 465

465

Polymorphisme et Object
Une variable de type Object peut être utilisée pour
référencer un objet de type quelconque :
Point p = new Point (...) ;
Pointcol pc = new Pointcol (...) ;
Fleur f = new Fleur (...) ;
Object o ;
.....
o = p ; // OK
o = pc ; // OK
o=f;//OK

ENSI II1
Vu Pham 466

466
 Pourquoi?
Cette particularité peut être utilisée pour manipuler des
objets dont on ne connaît pas le type exact (au moins à un certain
moment).
Le cas d’une méthode qui se contente de transmettre à une autre
méthode une référence qu’elle a reçue en argument
Si on souhaite appliquer une méthode précise à un objet
référencé par une variable de type Object, il faudra
obligatoirement effectuer une conversion appropriée
(Explicite).

ENSI II1
Vu Pham 467

467

Méthodes de la classe Object

La classe Object dispose de quelques méthodes qu’on peut soit
utiliser telles quelles, soit les redéfinir.

Les plus importantes sont:

□ toString
□ equals.

ENSI II1
Vu Pham 468

468
 La méthode toString
Elle fournit une chaîne, c’est-à-dire un objet de type
String.

La méthode toString de la classe Object fournit

une chaîne contenant :
 Le nom de la classe concernée,
 L’adresse de l’objet en hexadécimal (précédée de @).

ENSI II1
Vu Pham 469

469

Exemple
public class ToString1
{
public static void main (String args[])
{
Point a = new Point (1, 2) ;
Point b = new Point (5, 6) ;
[Link] ("a = " + [Link]()) ;
[Link] ("b = " + [Link]()) ;
}
}
Affichage:
a = Point@fc17aedf
b = Point@fc1baedf

ENSI II1
Vu Pham 470

470
 Méthode toString
La méthode toString d’une classe a la
particularité d’être automatiquement appelée
en cas de besoin d’une conversion implicite en
chaîne.
C’est le cas de l’opérateur + lorsqu’il dispose
d’un argument de type chaîne, ce qui permet
d’écrire par exemple :
[Link] ("a = " + a) ;
et ce, quels que soient le type de la référence o
et celui de l’objet effectivement référencé par o.
ENSI II1
Vu Pham 471

471

La méthode equals
La méthode equals définie dans la classe Object se contente
de comparer les adresses des deux objets concernés. Ainsi,
avec :

Object o1 = new Point (1, 2) ; Object o2 = new Point (1, 2) ;

L’expression [Link](o2) a pour valeur false

On peut bien sûr redéfinir cette méthode dans n’importe

quelle classe.

ENSI II1
Vu Pham 472

472
 La méthode equals
class Point
{ .....
boolean equals (Point p) { return ((p.x==x) && (p.y==y)); }
}
Point a = new Point (1, 2) ;
Point b = new Point (1, 2) ;
 l’expression [Link](b) aura bien sûr la valeur true.

En revanche, avec :
Object o1 = new Point (1, 2) ;
Object o2 = new Point (1, 2) ;
l’expression [Link](o2) aura la valeur false car on aura
utilisé la méthode equals de Object et non celle de Point.

ENSI II1
Vu Pham 473

473

Classes et méthodes finales

ENSI II1
Vu Pham 474

474
 Exemple

ENSI II1
Vu Pham 475

475

Les classes abstraites

Une classe abstraite est une classe qui ne permet pas d’instancier
des objets.
Elle ne peut servir que de classe de base pour une dérivation.
abstract class A
{ .....
}

Dans une classe abstraite, on peut trouver classiquement des

méthodes et des champs, dont héritera toute classe dérivée. Mais on
peut aussi trouver des méthodes dites abstraites, c’est àdire dont on
ne fournit que la signature et le type de la valeur de retour. Par
exemple :
abstract class A
{ public void f() { ..... } // f est définie dans A
public abstract void g(int n) ; // que l’en-tête
}
méthode différée ou
retardée

ENSI II1
Vu Pham 476

476
 Exemple

ENSI II1
Vu Pham 477

477

Classe abstraite
Dès qu’une classe comporte une ou plusieurs
méthodes abstraites, elle est abstraite, et ce
même si l’on n’indique pas le mot-clé abstract
devant sa déclaration.

Une méthode abstraite doit obligatoirement être

déclarée public.

Dans l’en-tête d’une méthode déclarée abstraite,

les noms d’arguments doivent figurer (bien qu’ils
ne servent à rien)

ENSI II1
Vu Pham 478

478
 Classe abstraite

ENSI II1
Vu Pham 479

479

Les interfaces
• Définit les en-têtes d’un certain
nombre de méthodes, ainsi que des
constantes.

• Cas particulier de classe abstraite???

ENSI II1
Vu Pham 480

480
 Les interfaces
Une classe pourra implémenter plusieurs
interfaces (alors qu’une classe ne pouvait
dériver que d’une seule classe abstraite),

La notion d’interface va se superposer à celle

de dérivation les interfaces pourront se dériver,

On pourra utiliser des variables de type

interface.

ENSI II1
Vu Pham 481

481

Interface et héritage
Java n'autorise pas l'héritage multiple: une des
raisons de cette restriction est la complexité de
l'implémentation pour le compilateur.

La notion d'interface a donc été introduite en Java

et elle permet de récupérer la plupart des
fonctionnalités de l'héritage multiple.

Cette décision dans la conception de Java est en

fait une simplification apportée au langage Java.

ENSI II1
Vu Pham 482

482
 Définition d’une interface
le mot-clé interface à la place de class

public interface I
{

void f (int n) ; / / en-tête d’une méthode f

void g() ; / / en-tête d’une méthode g Par défaut
publique et abstraite
}

ENSI II1
Vu Pham 483

483

Implémentation d’une interface

class A implements I
{ // A doit (re)définir les méthodes f et g prévues dans l‘ interface I
//sinon erreur de compilation
}

public interface I1
{ void f() ;
} Implémenter plusieurs interfaces
public interface I2
{ int h() ;
}
class A implements I1, I2
{ // A doit obligatoirement définir les méthodes f et h prévues dans
I1 et I2
}

ENSI II1
Vu Pham 484

484
 Polymorphisme
public interface I { .....}

I i ; // i est une référence à un objet d’une classe

implémentant l’interface I

class A implements I { ..... }

.....
I i = new A(...) ; // OK

ENSI II1
Vu Pham 485

485

Interface et classe dérivée

interface I
{ void f(int n) ;
void g() ;
}

class A { ..... }
class B extends A implements I
{ // les méthodes f et g doivent soit être déjà définies
dans A,
// soit définies dans B
}

ENSI II1
Vu Pham 486

486
 Interface et constantes
interface I
{ void f(int n) ;
void g() ;
static final int MAXI = 100 ;
}

class A implements I
{ // doit définir f et g
// dans toutes les méthodes de A, on a accès à MAXI
:
// par exemple : if (i < MAXI) .....
}

ENSI II1
Vu Pham 487

487

Dérivation d’une interface

On peut définir une interface comme une
généralisation d’une autre. Pour ceci, on utilise le
mot- clé extends, ce qui conduit à parler d’héritage
ou de dérivation

interface I1
{ void f(int n) ;
static final int MAXI = 100 ;
}

interface I2 extends I1
{ void g() ;
static final int MINI = 20 ;
}

ENSI II1
Vu Pham 488

488
 Dérivation d’une interface
La définition de I2 est totalement
équivalente à :
interface I2
{ void f(int n) ;
void g() ;
static final int MAXI = 100 ;
static final int MINI = 20 ;
}

ENSI II1
Vu Pham 489

489

Chapitre 4
Les packages et la gestion des exceptions

[Link]@[Link]
ENSI II1
Vu Pham 490

490
 Plan
Les packages
Les exceptions
Notion d'exception
Définir sa propre exception
Traitement d'une exception
Principe de propagation d'une exception
Le bloc finally
Exception contrôlée vs exception non contrôlée

ENSI II1
Vu Pham 491

491

Les packages

ENSI II1
Vu Pham 492

492
 Package (paquetage)

La notion de paquetage correspond à un regroupement

logique sous un identificateur commun d’un ensemble de
classes.

Elle est proche de la notion de bibliothèque que l’on

rencontre dans d’autres langages.

Elle facilite le développement et la cohabitation de logiciels

conséquents en permettant de répartir les classes
correspondantes dans différents paquetages.

Le risque de créer deux classes de même nom se trouve

alors limité aux seules classes d’un même paquetage.

ENSI II1
Vu Pham 493

493

Attribution d’une classe à un paquetage

Un paquetage est caractérisé par un nom qui est soit un
simple identificateur, soit une suite d’identificateurs séparés
par des points, comme dans :
MesClasses
[Link]
[Link]
L’attribution d’un nom de paquetage se fait au niveau du
fichier source: toutes les classes d’un même fichier source
appartiendront donc toujours à un même paquetage.

Pour ce faire, on place, en début de fichier, une instruction

de la forme :
package xxxxxx ;
dans laquelle xxxxxx représente le nom du paquetage

ENSI II1
Vu Pham 494

494
 Utilisation d’une classe d’un paquetage
Pour utiliser une classe appartenant à un
paquetage, il est nécessaire de fournir
l’information correspondante au compilateur.

Pour ce faire, il faut:

citer le nom du paquetage avec le nom de la classe,
utiliser une instruction import en y citant soit une
classe particulière d’un paquetage, soit tout un
paquetage.

ENSI II1
Vu Pham 495

495

En citant le nom de la classe

Si vous avez attribué à la classe Point le nom de
paquetage MesClasses par exemple, vous pourrez
l’utiliser simplement en la nommant
[Link].
Par exemple :
[Link] p = new [Link] (2, 5) ;
.....
[Link]() ; // ici, le nom de paquetage n’est pas requis
Evidemment, cette démarche devient fastidieuse
dès que de nombreuses classes sont concernées.

ENSI II1
Vu Pham 496

496
 En important une classe
L’instruction import permet de citer le nom
(complet) d’une ou plusieurs classes:
import [Link], [Link] ;

À partir de là, utiliser les classes Point et Cercle

sans avoir à mentionner leur nom de
paquetage.

ENSI II1
Vu Pham 497

497

En important un paquetage
La démarche précédente s’avère elle aussi fastidieuse
dès qu’un certain nombre de classes d’un même
paquetage sont concernées.
Pour utiliser toutes les classes du paquetage
MesClasses :
import MesClasses.* ;
Précautions
L’instruction : import MesClasses ;
ne concerne que les classes du paquetage
MesClasses.
Si, par exemple, il y a paquetage nommé
MesClasses.Projet1, ses classes ne seront nullement
concernées

ENSI II1
Vu Pham 498

498
 Les paquetages standards
Les nombreuses classes standard avec
lesquelles Java est fourni sont structurées en
paquetages.

Il existe un paquetage particulier nommé

[Link] qui est automatiquement importé par
le compilateur: permet d’utiliser des classes
standard telles que Math, System, Float ou
Integer, sans avoir à introduire d’instruction
import.

ENSI II1
Vu Pham 499

499