Chapitre 1 Présentation générale du langage JAVA

Java en quelques mots

• Développé en 1995 par Sun MicroSystem qui a été rachetée en 2009 par la société Oracle
• Orienté-Objet dérivé du C++
• Possède une bibliothèque de classes très riche
• Langage indépendant des plates-formes et des environnements des SE (Portabilité)
• Compilateurs et environnements gratuits

Premier programme Java

Le code source du premier programme (Exp 1)
• On désire écrire un programme qui, au soir d'élections, puisse calculer:
- nombre de sièges à pourvoir

- nombre de listes en compétition

- pour chaque liste : son nom, son nombre de voix
• Avec ces renseignements, l'application calcule les sièges obtenus par chacune des listes et
les affiche sur l'écran.

• En langage C, nous aurions probablement utilisé une structure pour représenter une liste
participant à l'élection. Elle aurait pu être de la forme suivante :
• struct t_liste {
char nom[15];

long voix;
int sieges;};
• Notion de structure n'existe pas dans le langage Java.
• Remplacer la notion de structure par celle de classe créer une classe pour mémoriser les
informations sur une liste.
Exemple 2
public class BonjourAmis {public static void main(String[] args){

System.out.println(" Bonjour les amis"); }

• Classe : « BonjourAmis » donc le fichier qui

la contient doit s’appeler en tenant compte des majuscules et minuscules

Règles et conventions d’écriture

• Règles:
– 1 classe Java = 1 fichier

– Nom du fichier = <nom de la classe>.java (ex : BonjourAmis.java)

• Conventions:
- Nom de la classe commence par une majuscule (ex :BonjourAmis )

- Nom des méthodes commence par une minuscule (ex : main)

- Nom des constantes entièrement en majuscule (ex : Math.PI)

Compilation d’un code source
• Un code source ne peut être exécuté directement par un ordinateur

• Il faut traduire ce code source dans un langage que l’ordinateur (le processeur de l'ordinateur)
peut comprendre (langage natif)

• Un compilateur est un programme qui effectue cette traduction

Compilation «classique» (C/C++ ...)

Compilation en Java bytecode

• En Java, le code source n’est pas traduit directement dans le langage de l’ordinateur

• Il est d’abord traduit (compilé) dans un langage appelé « bytecode » qui est le langage d’une
machine virtuelle (JVM ; Java Virtual Machine)

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

La compilation fournit du bytecode

Exécution du bytecode
• Le bytecode doit être exécuté (interprété) par une JVM
• Cette JVM n'existe pas ; elle est simulée par un programme qui:
– lit les instructions (en bytecode) du programme .class,

– les traduit dans le langage natif du processeur de l’ordinateur (que le processeur de

l'ordinateur peut comprendre )
– lance leur exécution

JVM
• Les systèmes qui veulent pouvoir exécuter un programme Java doivent fournir une JVM
• A l'heure actuelle, tous les systèmes (UNIX, Windows, MacOS ou GNU/Linux) ont
une JVM

Le bytecode peut être exécuté par n'importe quelle JVM

• Si un système possède une JVM, il peut exécuter tous les fichiers .class compilés sur n'importe quel
autre système

Avantages de la JVM
• Grâce à sa portabilité, le bytecode d'une classe (petite taille) peut être chargée depuis une
machine distante du réseau, et exécutée par une JVM locale

• La JVM fait de nombreuses vérifications sur le bytecode avant son exécution :

– permet de s'assurer que le bytecode est compatible avec la machine virtuelle

– effectue l'allocation mémoire nécessaire

• La JVM apporte donc:

– de la souplesse pour le chargement du code à exécuter

– mais aussi de la sécurité pour l'exécution de ce code

Inconvénient • Les vérifications effectuées sur le bytecode et l'étape d'interprétation de ce
bytecode (dans le langage natif du processeur) ralentissent l'exécution des classes Java

• Mais les techniques « Just In Time » ou « Hotspot » réduisent ce problème : elles permettent de
compiler en code natif le bytecode des fonctions, de stocker le résultat de cette compilation et
d'exécuter ce code compilé chaque fois que ces fonctions sont invoquées.

• Le but d'un compilateur JIT (Just In Time) est donc d'améliorer les performances de l'exécution du
bytecode.

Java et les autres langages

• Java est devenu en quelques années le langage de développement le plus utilisé, surtout pour les
applications qui ont besoin d'une grande portabilité ou d'une grande souplesse sur Internet

• Pour les applications qui nécessitent une très grande rapidité d'exécution, on préfère encore les
langages C ou C++

Plate-forme Java

Principes de base de la programmation orientée objet

Langage orienté objet
• Manipule des objets
• Les programmes sont découpés suivant les types des objets manipulés
• Les données sont regroupées avec les traitements qui les utilisent (un bon principe)
• Un module regroupe, par exemple, tout ce que l’on peut faire avec une facture, avec

toutes les données nécessaires pour ces traitements

Notion d’objet
• Toute entité identifiable ( concrète ou abstraite) peut être considérée comme un objet
• Un objet réagit à certains messages qu'on lui envoie de l'extérieur ; la façon dont il réagit
détermine le comportement de l'objet

• Il ne réagit pas toujours de la même façon à un même événement ; sa réaction dépend de

l’état dans lequel il est
• 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
• Le comportement est donné par des fonctions ou sous-programmes, appelées méthodes

Interactions entre objets

• Les objets interagissent en s’envoyant des messages

• Les méthodes d’un objet correspondent aux messages qu’on peut lui envoyer : quand un

objet reçoit un message, il exécute la méthode correspondante

Exemples :
Objet qui reçoit le message Message envoyé par un autre objet

• objet1.decrisToi();

• employe.setSalaire(1000);

• voiture.demarrer();

• voiture.vaAVitesse(50);
Programmation orientée objet (POO)
• La POO est un paradigme: une manière de "modéliser le monde" avec des objets ayant un état
interne et un comportement, et s'échangeant des messages

• Un programme est constitué d'objets qui collaborent pour fournir les fonctionnalités que l'on
demande à l'application

• La POO introduit de nouveaux concepts, en particulier ceux d’objets, d’encapsulation, de classe,

d’héritage et de polymorphisme.

Chapitre 2 Types de données, opérateurs et instructions de contrôle en Java

Types de données en Java
• Toutes les données manipulées par Java nesont pas tous des objets
• 2 grands groupes de types de données :
– types primitifs

– objets (instances de classe)

• Java manipule différemment les valeurs des types primitifs et les objets : les variables
contiennent des valeurs de types primitifs ou des références aux objets
Types primitifs

• Exp:

– 2589L : constante de type long

– 456.7 : de type double

– 123F : de type float

Valeurs par défaut

• Si elles ne sont pas initialisées, les variables

d’instance (comportement d’un objet)

reçoivent des valeurs par défaut

Opérateurs

• Les plus utilisés sont:

= + - * / % ++ -- += -= *= /= != > < >= <= && || ! (et, ou, négation)

• Exemples d’utilisation des opérateurs

• int x = 9, y = 2;

• int z = x/y; // division entière (z = 4)

• z = x++ / y; // z = 4 puis x = 10

• z = ++x / y; // x = 11 puis z = 5

• if (z == y) // et pas un seul "="

• x += y;

• if (y != 0 && x/y > 8) // raccourci

Opérateur instanceof
• Comparaison de type avec instanceof

• La syntaxe est : objet instanceof nomClasse

• Le résultat est un booléen :

– true si l’objet est une instance de la classe

– false sinon

• Exp: if (x instanceof Livre)

Instructions de contrôle
if... else
• if (expressionBooléenne)
{bloc-instructions ou instruction}
else

{bloc-instructions ou instruction}

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;
switch
switch(expression) {
case val1: instructions;

break;
…
case valn: instructions;
break;
default: instructions;
}

expression est de type char, byte, short, ou int

while
• while(expressionBooléenne)
{bloc-instructions ou instruction}

• do{
bloc-instructions ou instruction
}while(expressionBooléenne)
for

• for(init; test; incrément){

instructions;
}
• est équivalent à
init;

while (test) {
instructions;
incrément;
}

Instructions liées aux boucles

• break permet de sortir d’un bloc (exp. Boucle for) et de continuer l’exécution après le bloc
• continue force la suite de l’exécution à l’itération suivante

Exemple de continue et break

int somme = 0;
for (int i=0; i < tab.length; i++) {

if (tab[i] == 0) break;
if (tab[i] < 0) continue;
somme += tab[i];
} System.out.println(somme);

Autre exemple (continue)

• Imaginons que l'on veuille afficher pour x allant de 1 à 10 la valeur de 1/(x-7) ... il est
évident que pour x=7 il y aura une erreur.
• Heureusement, grâce à l'instruction continue il est possible de traiter cette valeur à part
puis de continuer la boucle!
Solution ?
x=1;
while (x<=10) {

if (x == 7) {
System.out.println("Division par zéro!");

continue; } Boucle infinie

a = 1/(x-7);
System.out.println(a);
x++; }
Solution

x=1;
while (x<=10)
{ if (x == 7) { System.out.println("division par 0");
x++;
continue; }

a = 1/(x-7);
System.out.println(a);
x++; }

Chapitre 3 :Classes et objets

Classes en Java
Regrouper les objets
• Les objets qui collaborent dans une application sont souvent très nombreux
• Mais on peut le plus souvent dégager des types d'objets : des objets ont une structure et
un comportement très proches, ou bien identiques
• Par exemple, tous les livres dans une application de gestion d'une bibliothèque

• La notion de classe correspond à cette notion de types d'objets

Notion de classe
• Une classe est un moule (modèle) pour créer des objets
• Les objets créés sont les instances de la classe
• Composition d’une classe:
– variables, ou champs (donnent l’état des instances)

– méthodes (indiquent les types de messages qui

pourront être envoyés aux instances)
– constructeurs (créent les instances)
• Les variables et les méthodes s’appellent les membres de la classe

Exemple : classe Livre

Rôles d’une classe

• La notion de classe est centrale

• Une classe est:

– un type qui décrit une structure (variables d'état) et un comportement (méthodes)

– un module pour décomposer une application en entités plus petites

– un générateur d’objets (par ses constructeurs)

• Une classe permet d'encapsuler les objets : les membres public sont vus de l'extérieur mais les
membres private sont cachés (niveaux d'accès)

Eléments d’une classe

• Les constructeurs (il peut y en avoir plusieurs) servent à créer de nouvelles instances de la classe

• Quand une instance est créée, son état est conservé dans les variables d’instance

• Les méthodes déterminent le comportement des instances de la classe quand elles reçoivent un
message ; elles peuvent modifier l'état de l'objet

Classes et instances
• Une instance d’une classe est créée par un des constructeurs de la classe

• Une fois qu’elle est créée, l’instance:

– a son propre état interne (les valeurs des variables)

– partage le code qui détermine son

comportement (les méthodes) avec les autres instances de la classe

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

Création d’une instance

Plusieurs constructeurs (surcharge)

Constructeur par défaut

• Lorsque le code d’une classe ne contient pas de constructeur, un constructeur par défaut sera

automatiquement ajouté par Java permettant d’allouer l’espace mémoire pour un objet

• S’il existe au moins un constructeur créé par un utilisateur, le constructeur par défaut n’est plus
considéré

• Il est fortement conseillé de programmer soi- même le constructeur

Méthodes
Types de méthode
• Une méthode ressemble à une procédure ou à une fonction dans les autres langages. Elle
se compose d’un en-tête et d’un bloc.
• Il y a des méthodes qui servent à donner accès aux variables depuis l’extérieur de la classe
: – les accesseurs (créer par l’utilisateur) pour lire les valeurs des variables
– les modificateurs pour modifier leur valeur

• Enfin, des méthodes (private) servent de « sous- programmes » utilitaires aux autres
méthodes de la classe
Paramètres d’une méthode
• Souvent les méthodes ou les constructeurs ont besoin qu’on leur passe des données
initiales sous la forme de paramètres
• On doit indiquer le type des paramètres dans la déclaration de la méthode :
setSalaire(double unSalaire) calculerSalaire(int indice, double prime)
• Quand la méthode ou le constructeur n’a pas de paramètre, on ne met rien entre les
parenthèses : getSalaire()

Type retour d’une méthode

• Quand la méthode renvoie une valeur, on doit indiquer le type de la valeur renvoyée dans
la déclaration de la méthode : double calculSalaire(int indice, double prime)
• Le pseudo-type void indique qu’aucune valeur n’est renvoyée :
void setSalaire(double unSalaire)

Exemple de méthodes

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 le même nombre de paramètres qu’une méthode existante :
• En Java, il est interdit de surcharger une méthode en changeant le type de retour

• Par exemple, il est interdit d'avoir ces deux méthodes dans une classe :

int calculerSalaire(int x) double calculerSalaire(int x)

Variables
Types de variables
• Les variables d’instances:
– sont déclarées en dehors de toute méthode
– conservent l’état d’un objet, instance de la classe
– sont accessibles et partagées par toutes les méthodes

• Les variables locales:

– sont déclarées à l’intérieur d’une méthode
– ne sont accessibles que dans le bloc dans lequel elles ont été déclarées
Variable locale ou variable d’instance ?

• Il arrive d’hésiter entre mettre une variable:

– comme variable locale d’une méthode
– ou comme variable d’instance de la classe
• Si la variable est utilisée par plusieurs méthodes de la classe, la variable devra être une
variable d’instance, sinon c’est une variable locale

Déclaration des variables

• Toute variable doit être déclarée avant d’être utilisée
• Déclaration d’une variable : on indique au compilateur que le programme va utiliser une
variable de ce nom et de ce type

• double prime;
• Employe e1;
• Point centre;
Affectation
• L’affectation d’une valeur à une variable est effectuée par l’instruction:

variable = expression;
• L’expression est calculée et ensuite la valeur calculée est affectée à la variable
• Exemple :
x = 3;

x = x + 1;
Initialisation d’une variable
• Une variable doit être initialisée (recevoir une valeur) avant d’être utilisée dans une
expression

• Si elles ne sont pas initialisées par le programmeur, les variables d’instance reçoivent les
valeurs par défaut de leur type (0 pour les types numériques, par exemple)
• L’utilisation d’une variable locale non initialisée provoque une erreur (pas d’initialisation
par défaut)
• On peut initialiser une variable en la déclarant

• La formule d’initialisation peut être une expression complexe :

– double prime = 2000.0;
– Employe e1 = new Employe(«Ben salah »,« Ali »);
– double salaire = prime + 5000.0;

Déclaration / création

• Il ne faut pas confondre entre:

– déclaration d’une variable et

– création d’un objet référencé par cette variable

• « 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éé

• Comment on crée cet objet?

• Il aurait fallu écrire : public static void main(String[] args) {

Employe e1; Déclaration

e1 = new Employe(« Bensalah », « ali ») ;

e1.setSalaire(1200);

...

} Création

Désigner les variables d’une instance

• Soit un objet o1 ; la valeur d’une variable v de o1 est représentée dans un programme par o1.v

• Par exemple:

Cercle c1 = new Cercle(p1, 10);

System.out.println(c1.rayon); // affiche 10

• Remarque : le plus souvent les variables (Exp rayon) sont private et on ne peut y accéder
directement en dehors de leur classe

Accès aux membres d’une classe

Concept d'encapsulation
• L’encapsulation permet de protéger l'information contenue dans un objet et de ne
proposer que des méthodes de manipulation de cet objet

• Java permet plusieurs degrés d’encapsulation pour les membres (variables et méthodes)
et les constructeurs d’une classe

Types d'autorisation d'accès

• Les types d'autorisation d'accès sont des mots-clé spéciaux du langage qui modifient la
définition et le comportement d’une classe, d’une méthode ou d’une variable. Parmi eux
on distingue:
• private : seule la classe dans laquelle il est déclaré peut utiliser ce membre
• public : toutes les classes sans exception peuvent l’utiliser
• 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 )

Protection des attributs d’une classe

• En Java, la protection des attributs se fait classe par classe, et non pas objet par objet
• Un objet a accès à tous les attributs d’un objet de la même classe, même les attributs
privés (grâce aux accesseurs/modificateurs)

Protection de l’état interne d’un objet

• Autant que possible l’état d’un objet (les variables) doit être private
• Si on veut autoriser la lecture d’une variable, on lui associe un accesseur, auquel on donne
le niveau d’accessibilité que l’on veut.
• Si on veut autoriser la modification d’une variable, on lui associe un modificateur, qui
permet la modification tout en contrôlant la validité de la modification
Exceptions pour les protections des variables

• Dans de rares cas , on peut autoriser l’accès au paquetage, ou à tous (public)

– si la variable ne risque pas de recevoir des valeurs absurdes
– si l’on veut un accès rapide pour améliorer les performances

Mot-clé « this »

This
• Le code d’une méthode d’instance désigne
– l’instance courante, par le mot-clé this
– donc, les membres de l’instance courante en
les préfixant par « this. »
• this est optionnel pour désigner un membre de l’instance courante, lorsqu’il
n’y a pas d'ambiguïté
Exemple de this implicite
this explicite
• this est utilisé dans les cas suivants:

– pour distinguer une variable d’instance et un paramètre qui ont le même nom :

public void setSalaire(double salaire){

this.salaire = salaire; }

– l’objet veut passer une référence de lui même à un autre objet : salaire =
comptable.calculeSalaire(this); L’employé demande au
Comptable « calcule mon salaire »

this explicite

– Appel d’un constructeur au sein d’un autre constructeur:

public class Employe {

private String nom;

private double salaire;

public Employe (String n, double s)

{nom=n; salaire=s;}

public Employe()

{this(« Ben Salah », 1000.0);

// appel Employe (« Ben Salah », 1000.0); doit etre

// la premiere instruction du constructeur.

Méthodes et variables de classe

Variables de classe

• Certaines variables peuvent être partagées par toutes les instances d’une classe. Ce sont les
variables de classe (mot clé: static en Java)

• 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: une seule instance existe pour tous les objets de
la classe

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;

Employe .nbEmployes++; } ...}

La classe et non l’objet

Méthodes de classe

• Une méthode static:

– Précédée par le mot-clé « static »

– Invoquée depuis le nom de la classe et pas depuisune instance

– une seul instance existe pour tous les objets de la classe

• Exp:

public static int calculNbEmploye()

{return Employe. nbEmployes;}

• La plus classique des méthodes de classe : la fonction « main »

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.

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.calculNbEmploye()

La classe et non l’objet

Blocs d’initialisation static

• Les blocs static permettent d’initialiser les variables static trop complexes à initialiser dans leur
déclaration :

class UneClasse {

private static int[] tab = new int[25];

static {

for (int i = 0; i < 25; i++) { Ici je veux initialiser un tableau static à -1

tab[i] = -1;

} // fin du bloc static

...

• Ils sont exécutés une seule fois, quand la classe est chargée en mémoire

Référence d’un objet

• Une variable dont le type est une classe contient une référence à un objet

• Une référence est un «pointeur caché» sur un objet créé dynamiquement en mémoire

• L’espace mémoire alloué à un objet est situé dans le tas

• Lorsque l’objet n’est plus référencé, un « ramasse-miettes » (garbage collector) libère la mémoire
qui lui a été allouée

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 ?

Références
int m() {
A a1,a2;

a1 = new A();
a2 = a1;}

Références

int m() {

A a1,a2;

a1 = new A();

a2 = a1;
int m() {

A a1,a2;

a1 = new A();

a2 = a1;

int m() {

A a1,a2;

a1 = new 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
...le ramasse-miette interviendra à un moment aléatoire...

Ramasse-miettes

• Java ne dispose pas de mot-clés « delete » ou « free » pour libérer la mémoire allouée
dynamiquement par l’appel à « new »

• 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

Les « finaliseurs »
 • La méthode finalize() s'occupe de libérer les ressources nécessaires à un objet. Cette méthode est
appelée automatiquement par le ramasse-miettes lorsque l'instance n'est plus nécessaire. Cela peut
intervenir bien après la perte de l'objet.

Constantes nommées
• Le mot-clé final indique que la valeur de la variable (d'état ou locale) ne peut être

modifiée : on pourra lui donner une valeur une seule fois dans le programme (à la

déclaration ou ensuite)

• Une variable de classe static final est vraiment constante dans tout le programme ;

– exemple : static final double PI = 3.14;

Variable d'état final

• Une variable d’instance (pas static) final est constante pour chaque instance ; mais elle

peut avoir 2 valeurs différentes pour 2 instances (différence avec static)

• 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

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("Bibel");

–...

– e.nom = « Ben Mohamed »; // Autorisé !

– e.setSalaire(1200); // Autorisé !

– e = e2; // Interdit

Forcer un type en Java

• 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 (moulage, distribution de rôle) :

(type-forcé) expression

int x = 10, y = 3;

double z = (double)x / (double)y;

Casts autorisés

• En Java, 2 cas sont autorisés pour les casts :

– entre types primitifs,

– entre classes mère/ancêtre et classes filles (notion d’héritage)

Casts entre types primitifs

• Un cast entre types primitifs peut occasionner une perte de données : Par exemple, la conversion
d'un int (4 octets) vers un short (2 octets)

• Un cast peut provoquer une simple perte de précision: Par exemple, la conversion d'un long vers
un float peut faire perdre des chiffres significatifs mais pas l'ordre de grandeur

• Les affectations entre types primitifs peuvent utiliser un cast implicite si elles ne peuvent

provoquer qu'une perte de précision (ou, encore mieux, aucune perte)

• Sinon, elles doivent comporter un cast explicite

• Exemples :

• short s = 65; // cas particulier affectation int

"petit"

• s = 1000000; // provoque une erreur

• Le cast d'un nombre à virgule en un nombre entier tronque le nombre (ne l'arrondit pas) :

• int d = (int)1.99; // d = 1

Casts entre les objets

• Un objet d’une classe peut également être converti en un objet d’une autre classe, à une

condition : les classes en question doivent être liées par le mécanisme de l’héritage

• Mis à part cette restriction, le mécanisme de conversion est identique à celui utilisé pour

les variables de type primitif

• Voici un exemple de conversion d’une instance de la classe « sapin » vers la classe « arbre »

(où « sapin » est une sous-classe de la classe «

arbre »):

Sapin s ;

Arbre a ;

s = new Sapin() ; // on cree un objet s de la classe Sapin

a = (Arbre)s ; // on « force » s à devenir un objet de type Arbre

La classe Object

• Toutes les classes Java héritent d’une classe de base unique : la classe Object du package

java.lang. Ainsi, la classe Object est la superclasse de toutes les classes Java.

• public class Object { public Class getClasse();

public boolean equals(Object obj);

public String toString();

protected Object clone () throws

CloneNotSupportedException,

...

getClasse()
• La méthode getClasse() renvoie un objet de la classe Class qui représente la classe de l’objet.

Le code suivant permet de connaître le nom de la classe de l’objet:

• String nomClasse= monObjet.getClasse().getName();

equals()
• La méthode equals() implémente une comparaison par défaut. Sa définition dans Object compare
les références : donc obj1.equals(obj2) ne renverra true que si obj1 et obj2 désignent le même objet.

• Dans une sous classe (classe fille) de Object, pour laquelle on a besoin de pouvoir dire que deux
objets distincts peuvent être égaux, il faut redéfinir la méthode equals héritée de Object

toString()
• L'implémentation par défaut de la méthode toString() retourne une chaîne de caractère
construites à partir du nom de la classe et de la valeur de hash de l'instance:

public class Object { ...

public String toString() {return getClass().getName() + '@' +

Integer.toHexString(hashCode()); } }

• La méthode toString() de la classe Object permet de retourner une instance(redéfinition de la

méthode toString()).

• public class Employé {

...

public String toString() {

return "Employé est:"+ e.getNom() + e.getPrenom();

clone ()
• Le "clonage" d'un objet pourrait se définir comme la création d'une copie de cet objet.

• Object obj1=obj2.clone();
Paquetages
Définition d’un paquetage
• Les classes Java sont regroupées en paquetages (packages en anglais)
• Ils correspondent aux « bibliothèques » des autres langages comme le langage C,
Fortran,Ada, etc...
• Les paquetages permettent :
– de réunir des classes suivant un centre d’intérêt

commun
– la protection des attributs et des méthodes

Principaux paquetages
• java.lang : classes de base de Java
• java.util : utilitaires (Vector, ArrayList,...)
• java.io : entrées-sorties

• java.awt : interface graphique

• javax.swing : interface graphique avancée
• java.applet : applets
• java.net : réseau

•...

Importer une classe d’un paquetage

• Pour pouvoir désigner une classe d'un autre paquetage par son simple nom, il est possible
"d'importer" la classe par l'instruction import, placée juste avant l'en-tête de classe. import
java.util.ArrayList;

public class Classe {

...
ArrayList liste = new ArrayList();
• Les classes du paquetage java.lang sont automatiquement importées
• On peut importer toutes les classes d'un paquetage :
import java.util.*;
• Les classes du paquetage java.lang sont automatiquement importées
• On peut importer toutes les classes d'unpaquetage :

import java.util.*;

CHAPITRE 4. LES CHAÎNES DE CARACTÈRES

1. Introduction
• Une chaîne de caractère "String" est une suite ou une séquence de caractères

• Dans beaucoup de langages une chaîne de caractère n'est qu'un tableau de caractères,
alors qu'en Java elle est considérée comme étant un objet
• Cette classe sert à créer, stocker et gérer des chaînes de caractères
• Java propose 2 classes relatives aux chaînes de caractères:
• La classe String (chaîne de caractères non modifiables)
• La classe StringBuffer (chaîne de caractères modifiables à volonté)

1.1 Fonctionnalités de base de la classe String

• Déclaration d’une variable objet:
– String ch ;
– ch est destinée à contenir une référence à un objet de type String.

• Par ailleurs, la notation :"bonjour" désigne en fait un objet de type String

• ch = "bonjour" ;

1.1 Constructeurs
• La classe String dispose de deux constructeurs:
– String ch1 = new String () ; // ch1 contient la reference a une chaine vide
– String ch2 = new String("hello") ; // ch2 contient la reference a une chaine contenant la
suite "hello"

– String ch3 = new String(ch2) ; // ch3 contient la reference a une chaine copie de ch2, donc
contenant "hello"1

1.2 Un objet de type String n’est pas modifiable

• Un objet de type String n’est pas modifiable
• Il n’existe donc aucune méthode permettant d’en modifier la valeur. Mais il ne faut pas
perdre de vue qu’on manipule en fait des références à des objets
• Exp:

String ch1, ch2, ch ;

ch1 = "bonjour" ;
ch2 = "bonsoir" ;

1.2 Un objet de type String n’est pas modifiable

• Exécutons maintenant ces instructions :
ch = ch1 ;
ch1 = ch2 ;
ch2 = ch ;

• Nous obtenons ceci :

1.3 Opérations sur les Strings

1.3.1 Entrées-sorties de chaînes:
– Affichage des constantes chaînes par la méthode println : System.out.println ("bonjour") ;
– Lecture d’une chaine avec la classe clavier: import java.util.Scanner;
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
• Longueur d’une chaîne : la méthode length:
String ch = "bonjour" ;
int n = ch.length() ; // n contient 7
ch = "" ; n = ch.length () ; // n contient 0
• Remarque: La méthode length() utilisée par les strings est différente à l’attribut length utilisé par
les tableaux
1.3.2 Accès aux caractères d’une chaîne : charAt:
• La méthode charAt de la classe String permet d’accéder à un caractère de rang donné d’une chaîne
(le premier caractère porte le rang 0)
• Exp: String ch = "bonjour" ;
ch.charAt(0) correspond au caractère ’b’,
ch.charAt(2) correspond au caractère ’n’.
1.3.3 Concaténation de chaînes:
• L’opérateur « + » est défini lorsque ses deux opérandes sont des chaînes. Il fournit en
résultat une nouvelle chaîne formée de la concaténation des deux autres.
• Exp:
String ch1 = "Le langage " ;
String ch2 = "Java" ;
String ch = ch1 + ch2 ;

1.3.4 Recherche dans une chaîne:

• La méthode indexOf permet de rechercher, à partir du début d’une chaîne ou d’une position
donnée :
– la position du caractère (ou du début de la chaîne recherchée) si une correspondance a
effectivement été trouvée,
– la valeur -1 sinon.
• Il existe également les méthodes suivantes:
– lastIndexOf, pour examiner la chaîne depuis sa fin
– indexOf(car, i) pour rechercher à partir du caractère de rang I
• Exp:
String mot = "anticonstitutionnellement" ;
int n ;
n = mot.indexOf (’t’) ; // n vaut 2
n = mot.lastIndexOf (’t’) ; // n vaut 24
n = mot.indexOf ("ti") ; // n vaut 2
n = mot.lastIndexOf ("ti") ; // n vaut 12
n = mot.indexOf (’x’) ; // n vaut –1
1.3.5 Comparaisons de chaînes:
La méthode equals compare le contenu de deux chaînes :
String ch1 = "hello" ;
String ch2 = "bonjour" ;
ch1.equals(ch2) // cette expression est fausse
ch1.equals("hello") // cette expression est vraie
• La méthode equalsIgnoreCase effectue la même comparaison, mais sans distinguer les majuscules
des minuscules :
String ch1 = "HeLlo" ;
String ch2 = "hello" ;
ch1.equalsIgnoreCase(ch2) // cette expression est vraie
ch1.equalsIgnoreCase("hello") // cette expression est vraie
1.3.6 La méthode compareTo:
Permet d’effectuer des comparaisons lexicographiques de chaînes pour savoir laquelle de deux
chaînes apparaît avant une autre, en se fondant sur l’ordre des caractères
• La méthode compareTo s’utilise ainsi : chaîne1.compareTo(chaîne2)
• Elle fournit :
-un entier négatif si chaîne1 arrive avant chaîne2,
-un entier nul si chaîne1 et chaîne2 sont égales (on a alors chaîne1.equals(chaîne2)),
-un entier positif si chaîne1 arrive après chaîne2.
• Exp:

1.3.7 Modification de chaînes :

- Les objets de type String ne sont pas modifiables. Mais, la classe String dispose de quelques
méthodes qui créent une nouvelle chaîne obtenue par transformation de la chaîne courante
• Remplacement de caractères: La méthode replace crée une chaîne en remplaçant toutes
les occurrences d’un caractère donné par un autre:
String ch = "bonjour" ;
String ch1 = ch.replace(’o’, ’x’) ; // ch n’est pas modifiée, ch1 contient "bxnjxur"
• Extraction de sous-chaîne: La méthode substring permet de créer une nouvelle chaîne en extrayant
de la chaîne courante :
• Exp:
1- String ch = "anticonstitutionnellement" ;
String ch1 = ch.substring (5) ; // ch n’est pas modifiée, ch1 contient "onstitutionnellement"
2- String ch = "anticonstitutionnellement" ;
String ch1 = ch.substring (4, 16) ; // ch n’est pas modifiée, ch1 contient "constitution"
• Passage en majuscules ou en minuscules:
String ch = "LanGaGE_3" ;
String ch1 = ch.toLowerCase() ; // ch est inchangée, ch1 contient
"langage_3"
String ch2 = ch.toUpperCase() ; // ch n’est pas modifiée, ch2 contient "LANGAGE_3"
• Conversion d’un type primitif en une chaîne:
int n = 427 ;
String ch = String.valueOf(n) ; // fournit une chaine obtenue par formatage de la valeur contenue
dans n, soit ici «427 » Equivalent à:
ch = "" + n ; // utilisation artificielle d’une chaine vide pour pouvoir , recourir a l’operateur +

• Suppression des séparateurs de début et de fin:

La méthode trim crée une nouvelle chaîne en supprimant les éventuels séparateurs de début et de
fin (espace, tabulations, fin de ligne) :
String ch = " \n\tdes separateurs avant, pendant\t\n et apres \n\t " ;
String ch1 = ch.trim() ; // ch n’est pas modifiee, ch1 contient la chaine : "des séparateurs avant,
pendant\t\n et apres"
1.4 La classe StringBuffer

• Les objets de type String ne sont pas modifiables mais nous avons vu qu’il était possible de les
employer pour effectuer la plupart des manipulations de chaînes. Cependant, la moindre
modification d’une chaîne ne peut se faire qu’en créant une nouvelle chaîne
• Java dispose d’une classe StringBuffer destinée elle aussi à la manipulation de chaînes, mais dans
laquelle les objets sont modifiables
1.4 La classe StringBuffer
• La classe StringBuffer possède les méthodes :
– de modification d’un caractère de rang donné : setCharAt,
– d’accès à un caractère de rang donné : charAt,
– d’ajout d’une chaîne en fin : la méthode append accepte des arguments de tout type primitif et de
type String,
– d’insertion d’une chaîne en un emplacement donné : insert,
– de remplacement d’une partie par une chaîne donnée : replace,
– de conversion de StringBuffer en String : toString.
• Exp:
class TesterStringBuffer
{ public static void main (String args[])
{ String ch = "la java" ;
StringBuffer chBuf = new StringBuffer (ch) ; // chBuf contient «la java »
chBuf.setCharAt (3, ’J’); // chBuf contient « la Java »
chBuf.setCharAt (1, ’e’) ; // chBuf contient « le Java »
chBuf.append (" 2") ; // chBuf contient « le Java 2 »
chBuf.insert (3, "langage ") ; // chBuf contient « le langage Java 2 »
}}
2. Exercice d’application
• Écrire un programme qui lit au clavier un verbe du premier groupe (il s’assurera qu’il est bien
terminé par er) et qui en affiche la conjugaison au présent de l’indicatif. On supposera qu’il s’agit
d’un verbe régulier. Autrement dit, on admettra que l’utilisateur ne fournit pas un verbe tel que
manger (dans ce cas, le programme affichera nous mangons!).
• Les résultats se présenteront ainsi :
donnez un verbe regulier du premier groupe :
dire
*** il ne se termine pas par er - donnez-en un autre : chanter
je chante
tu chantes
il/elle chante
nous chantons
vous chantez
ils/elles chantent
3. Solution
• On lira bien sûr le verbe sous la forme d’une chaîne de caractères. À l’aide de la méthode
substring, on en extrait la fin qu’on compare avec la chaîne "er".
• Les différentes personnes de la conjugaison s’obtiennent en ajoutant au verbe, privé de
ses deux derniers caractères, l’une des terminaisons voulues fournies ici par un tableau de chaînes
terminaisons. On les fait précéder d’un sujet extrait, lui aussi, d’un tableau de chaînes Cours
Programmation Avancée sujets.
public class Conjug
{ public static void main (String args[])
{ final String sujets[] =
{ "je", "tu", "il/elle", "nous", "vous", "ils/elles"} ;
final String terminaisons [] =
{ "e", "es", "e", "ons", "ez", "ent" } ;
String verbe ;
int nbLettres ;
System.out.print ("donnez un verbe regulier du premier groupe : ") ;
while (true)
{ verbe = Clavier.lireString() ;
nbLettres = verbe.length() ;
String fin = verbe.substring (nbLettres-2, nbLettres) ;
if (fin.equals("er")) break ;
System.out.print
("*** il ne se termine pas par er - donnez-en un autre : ") ;
}
String rad = verbe.substring(0, nbLettres-2) ;
int n = terminaisons.length ;
for (int i=0 ; i<n ; i++)
System.out.println (sujets[i] + " " + rad + terminaisons[i]) ; }
Chapitre 5 Conteneurs

Tableaux
Particularités sur les tableaux
• 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 : length
– ils héritent des méthodes d’instance de Object
• Cependant, Java a une syntaxe particulière pour:
– la déclaration des tableaux
– leurs initialisations
Déclaration et création des tableaux
• Déclaration : la taille n’est pas fixée:
int[] tabEntiers; ou int tabEntiers[];
• Création : on doit donner la taille:
tabEntiers = new int[5];
• La taille ne pourra plus être modifiée par la suite

Initialisation des tableaux

• On peut lier la déclaration, la création et l’initialisation d’un tableau ; sa longueur est alors
calculée automatiquement d’après le nombre de valeurs données (attention, cette syntaxe
n'est pas autorisé ailleurs que dans la déclaration) :
int[] tabEntiers = {8, 2*8, 3, 5, 9};
Employe[] employes = {
new Employe(" Ali", "Ben Mohamed"),
new Employe("Sami", "Ben salah")
}
Tableaux-utilisation
• Affectation des éléments : l’indice commence à 0 et se termine à tabEntiers.length – 1
• Taille du tableau:
int l = tabEntiers.length; // l = 5
int e = tabEntiers[5]; /* Lève une exception ArrayIndexOutOfBoundsException */
• Déclarations dans une méthode: public int [] m(String[] t)
Paramètres de la ligne de commande :
exemple de tableau de chaînes
• class Arguments {
public static void main(String[] args) {
for (int i=0; i < args.length; i++)
System.out.println(args[i]);
}
}
• java Arguments Ali Sami
• Affichera :
Ali
Sami
Utilisation d’un tableau d’objets
• Une faute fréquente est d’initialiser un tableau d’objets et d’utiliser les objets du
tableau avant de les avoir créés:
Employe[] personnel = new Employe[100];
personnel[0].setNom("BenSalah");

Faux
Utilisation d’un tableau d’objets
Employe[] personnel = new Employe[100];
personnel[0] = new Employe ();
personnel[0].setNom("BenSalah");

Juste
Copier une partie d'un tableau dans un autre
• On peut copier les éléments un à un mais la classe System fournit une méthode static plus
performante :
• public static void arraycopy (Object tab_src, int ind_1er_élém_copié, Object tab_dest, int
tab_dest_ ind_1er_élém_copié, int nb_élém_copiés)
Comparer 2 tableaux
• On peut comparer l'égalité de 2 tableaux (au sens où ils contiennent les mêmes valeurs)
en comparant les éléments un à un
• On peut aussi utiliser la méthode static à 2 arguments de type tableau
java.util.Arrays.equals(type []a, type []b)
Tableaux à plusieurs dimensions
• Déclaration: int[][] notes;
• Création:
notes = new int[30][3]; // 3 notes, 30 étudiants
• Déclaration, création et initialisation et affectation
int[][] notes = { {10, 11, 9}, {15, 8, 10} ,...}
int x = notes [1][0] ; // x= 15

Remarques importantes

• Tout accès hors des limites d’un tableau lève une exception

• Tous les éléments d’un tableau sont de même type

• Les classes « Vector » et « ArrayList » (du package java. util) sont des tableaux qui peuvent
contenir des objets de types différents et sont redimensionnable

Stockage des Objets Vector, ArrayList, …

• Comme pour les tableaux, nous avons les listes en java qui permettent de stocker un
groupe d’objets
• Une liste associe des indices à des objets, elle se redimensionne automatiquement
lorsqu’on ajoute des éléments
• Mais une liste ne peut stocker que des références sur des objets, donc il faut toujours faire
un casting sur le résultat quand on récupère une référence sur un objet du conteneur
• Pour utiliser ces conteneurs (Collections) il faut faire appel au paquetage java. util: import
java. util.*;
Quelques méthodes de la classe Vector

• La classe Vector permet de manipuler des vecteurs dynamiques

• void addElements (Object obj): ajouter un élément à la fin de la liste.

• void clear(): supprimer tous les éléments de la liste.

• boolean contains(Object obj): vérifier si une instance existe dans une liste.

• Object elementAT(int index): retourner l’élément d’indice « index ».

Quelques méthodes de la classe Vector

• boolean isEmpty(): verifier si le vecteur est vide ou non.

• boolean remove(Object obj): supprimer la 1ere occurrence de l’objet obj.

• int size(): retourner la taille du vecteur.

• ...(Voir la documentation JDK)

Classe ArrayList
• La classe ArrayList offre des fonctionnalités d’accès rapide comparables à celles d’un
tableau d’objets
• Av: cette classe offre plus de souplesse que les tableaux d’objets dans la mesure où sa
taille (son nombre d’éléments) peut varier au fil de l’exécution (comme celle de n’importe
quelle collection)
• Inconvénient: Mais pour que l’accès direct à un élément de rang donné soit possible, il est
nécessaire que les emplacements des objets (plutôt de leurs références) soient contigus en
mémoire (à la manière de ceux d’un tableau). Aussi cette classe souffrira d’une lacune
inhérente à sa nature : l’addition ou la suppression d’un objet à une position donnée
ne pourra plus se faire en O(1) mais seulement en moyenne en O(N)
Quelques méthodes de la classe ArrayList

• Boolean add(Object obj): ajouter un élément à la fin de la liste. Si l’opération est reussit elle

retourne true, false sinon

• Object get(int index): retourner l’ élément d’indice « index »

• int indexof(Object obj): retourner la position de l’élément s’il exist, -1 sinon

• void clear() • boolean contains(Object obj)

• boolean remove(Object obj)

• Object remove(int index)

• int size()

Classe LinkedList
• La classe LinkedList permet de manipuler des listes dites "doublement chaînées "
• Av: Le grand avantage d’une telle structure est de permettre des ajouts ou des
suppressions à une position donnée avec une efficacité en O(1) (ceci grâce à un simple jeu
de modification de références)
• Limite: En revanche, l’accès à un élément en fonction de sa valeur ou de sa position dans
la liste sera peu efficace puisqu’il nécessitera obligatoirement de parcourir une partie de la
liste. L’efficacité sera donc en moyenne en O(N)

Tableau comparatif
 Remarque

• Contrairement aux LinkedLists, les ArrayLists sont rapides en lecture, même avec
un gros volume d'objets. Elles sont cependant plus lentes si vous devez ajouter ou
supprimer des données en milieu de liste. Pour résumer à l'extrême, si vous
effectuez beaucoup de lectures sans vous soucier de l'ordre des éléments, optez
pour une ArrayList ; en revanche, si vous insérez beaucoup de données au milieu de
la liste, optez pour une Linkedlist.

Exemple : ArrayList
• Package: import java.util.ArrayList;
• Déclaration: ArrayList<Employe> maListe= new ArrayList<Employe> ();
• Utilisation:
• int long= maListe.size();
get(int i)
• La fonction suivante permet de calculer la somme des éléments d’une ArrayList d’entiers :
• public static int somme(ArrayList<Integer> liste) {
int s=0;
for (int i= 0; i < liste.size(); i++) {
s= s + liste.get(i); }
return s;
}
add(Type element)
• ajoute un élément à la fin de la liste. Pour construire la liste [2,3,5, 7, 11], on écrira donc :
ArrayList<Integer> l= new ArrayList<Integer> ();
l.add(2); l.add(3); l.add(5); l.add(7); l.add(11);
Chapitre 6 Notion d’héritage, classe abstraite et interface

Héritage
Définition
• L’héritage est un mécanisme qui facilite l’écriture des classes et permet de rendre plus compact le
code source d’un programme. Le concept est le suivant : toutes les classes font partie d’une
hiérarchie stricte. Chaque classe possède des super-classes et un nombre quelconque de sous-
classes. Les sous-classes héritent des attributs et des comportements de leurs super-classes, ce qui
permet de ne pas réécrire le code concerné
• En Java, la classe Object se trouve au sommet de la hiérarchie des classes. Toutes les classes
héritent de cette super-classe
L’utilisation de l’héritage

• Si l'on regarde le code de la classe Cercle et celui de la classe Carre, on se rend compte
immédiatement de la similitude de la plupart des champs et des comportements
• L’héritage nous permet de regrouper des champs et des comportements communs dans une
super-classe (appelons-là Forme) dont les classes Cercle et Carre vont dériver. On dit encore que les
classes Cercle et Carre héritent des champs et des méthodes de la classe Forme
• En Java, pour signifier qu’une classe hérite d’une autre on utilise le mot-clé extends. Par
exemple, si la classe Cercle hérite de la classe Forme on écrira :
class Cercle extends Forme {
...
}

mot clé super

• Le mot clé super sert à accéder aux définitions de classe parente de la classe considérée (ces
définitions pouvant être des méthodes ou des constructeurs)
Constructeur d’une classe dérivée
• Le constructeur d’une «sous-classe » peut appeler le constructeur de la classe «mère »
en utilisant le mot-clé « super »
• Le mot-clé « super » doit être à la première ligne du code du constructeur de la «sous-
classe »
Exemple

Avantages de l’héritage
• L'héritage supprime, en grande partie, les redondances dans le code. Une fois la
hiérarchie de classes bien établie, on localise en un point unique les sections de code
(celles-ci restant à tous moments accessibles grâce au mot clé super)
• Il est possible de rajouter facilement une classe, et ce à moindre coût, puisque l'on peutréutiliser le
code des classes parentes
L’héritage multiple
• La forme d’héritage étudiée précédemment s’appelle « l’héritage simple ». Dans un tel
héritage, chaque classe Java a une seule super- classe directe
• Dans d’autres langages (notamment en C++), les classes peuvent avoir plusieurs super-classes.
Elles héritent alors de la combinaison des variables et des méthodes de toutes leurs super-
classes. Cela s’appelle « l’héritage multiple »
• l’héritage multiple est un mécanisme puissant mais très complexe qui alourdit souvent le
code. Pour cette raison, Java se limite à l’héritage simple. Nous verrons par la suite qu’il est possible
de simuler l‘héritage multiple sans en avoir les inconvénients grâce au concept d’interface
Remarques

• Une classe déclarée avec le mot-clé «final» ne peut être dérivée

• Le mot-clé «protected» permet d’affiner la visibilité des variables et des méthodes des

classes «parent» (la classe elle-même et ses filles peuvent voir ces variables/méthodes)

protected
• Il s’agit d’une forme de protection entre classe et sous-classes. Le mot-clé protected signifie
que des méthodes et des variables d’une classe donnée demeurent accessibles à toute
classe du même package (différence avec C++), mais ne sont accessibles, en dehors du
package, qu’aux sous-classes de la classe à laquelle elles appartiennent
Résumé

Polymorphisme
Principe du polymorphisme
• Un même message envoyé vers divers objets peut déclencher des actions (méthodes)
pouvant prendre des formes différentes
• Le choix de la méthode à déclencher est effectué au moment de l’exécution. On parle
de liaison dynamique

EXEMPLES

• Le polymorphisme autorise la référence et l'objet à être de types différents: Objet monObj = new
Cercle ();
• Avec le polymorphisme le type de la référence peut être du type de la superclasse de l'objet.
• Exemple : Il est possible de créer des tableaux polymorphes.
Objet [] z = new Objet [3];
z [0] = new Cercle ();
z [1] = new Rectangle();
z [2] = new Ligne();
for ( int i = 0; i < z. length ; i ++) {
z [i]. afficher(); }
• Grâce à l'héritage et au polymorphisme, une seule et même méthode peut être utilisée pour
plusieurs objets de types différents.

Classe abstraite
• Définition
• Les classes abstraites sont des classes dont le seul but est de fournir des informations
communes aux sous-classes
• Les classes abstraites n’ont pas d’instance, mais peuvent contenir tout ce qu’une classe
normale peut contenir (attributs et méthodes...)
• Une méthode abstraite est une méthode sans code devant absolument être redéfinie dans
une des sous-classes
• Une classe abstraite contient au moins une méthode abstraite et ne peut être instanciée
• Définie par le mot mot-clé « abstract »

Exemple
• Déclaration
public abstract class ObjetGraphique {
public Color couleur ;
public abstract void dessiner ( Graphics g ) ;
public void setCouleur(Color c ) { couleur = c ; }
public Color getCouleur( ) { return couleur ; }
}
• Utilisation
public class CercleGraphique extends
ObjetGraphique {
public void dessiner (Graphics g ) {
g.DrawOval( x, y, r, r ) ;
}
}
public class RectangleGraphique extends
ObjetGraphique {
public void dessiner (Graphics g ) {
g.DrawRect( x, y, l, h ) ;
}
}

Interface
Définition
• Le mécanisme de l’interface est une généralisation du concept de classe abstraite.
Plus précisément, une interface est une classe dont toutes les méthodes sont abstraites. On
n'a donc plus besoin de spécifier que les méthodes sont abstraites car elle doivent forcément l'être
• on introduit une interface non plus par le mot clé class mais par le mot interface
• bien que les interfaces bénéficient aussi du mécanisme de l’héritage, on n'hérite pas d'une
interface, mais on l'implémente. En d'autres termes, on doit forcément fournir le code de toutes les
méthodes de l'interface utilisée (sauf dans le cas d'une classe abstraite qui implémente une
interface, ou bien d'une interface dérivée d'une autre)
• On utilise le mot-clé implements (et non extends) pour signifier qu’on implémente une interface
• Une interface ne peut pas être instanciée
EXEMPLE

Remarque

• La différence essentielle entre une classe abstraite dont toutes les

méthodes seraient

abstraites et une interface réside dans le fait que l'on ne peut hériter que
d'une seule

classe (héritage simple), alors que l'on peut implémenter plusieurs

interfaces. C'est une

solution pour simuler l'héritage multiple

Chapitre 7 Exceptions
Notion
• La notion d’exception est offerte aux programmeurs Java pour résoudre de manière
efficace et simple le problème de la gestion des erreurs émises lors de l’exécution d’un
programme
• Contrairement au C/C++, les exceptions et leur traitement font partie intégrante du
langage
• L’idée fondamentale est qu’une méthode qui rencontre un problème impossible à traiter
immédiatement lève une exception en espérant que le programme appelant pourra
la traiter
• Une méthode qui désire gérer ce genre de problèmes peut indiquer qu’elle est disposée à
intercepter l’exception
• Une fois acquis le principe de cette forme de traitement d'erreur, vous pourrez utiliser les
classes d'exceptions Java prédéfinies ou créer vos propres classes pour traiter les erreurs qui
peuvent survenir dans vos méthodes
Exceptions prédéfinies
• En Java, les exceptions sont de véritables objets
• Ce sont des instances de classes qui héritent de la classe Throwable. Lorsqu’une exception
est levée, une instance de la classe Throwable est créée

Hiérarchie des classes pour les exceptions

• Les instances de la classe Error sont des erreurs internes à la machine virtuelle Java. Elles sont
rares et fatales. L'application Java s'arrête instantanément dès l'apparition d'une exception de la
classe Error.
• Les sous-classes de la classe Exception (moins graves ) sont réparties en deux catégories :
– les exceptions d’exécution (runtime) sont souvent l’effet du manque de robustesse du code. Par
exemple, l’exception NullPointerException est levée lorsqu’on manipule un objet non instancié
(oubli de l’instruction new)
– les autres exceptions correspondent à des événements anormaux échappant au contrôle du
programme. Par exemple, l’exception EOFException est levée si on essaie de lire au-delà
d’un fichier
Intercepter une exception : le mot clé throws
• Si une méthode est susceptible de lever une exception et si elle ne peut pas la traiter, elle
se doit de prévenir le système
• Pour ce faire, on utilise le mot clé throws dans la définition de la méthode. Ce mot clé
permet d'avertir le système qu'une certaine catégorie d'exception ne sera pas traitée en local (la
méthode lève seulement l’exception et ne la traite pas)

Les exceptions définies par le programmeur

• Java offre au programmeur la possibilité de définir ses propres exceptions

• Ces exceptions doivent hériter d’une autre exception de la hiérarchie des classes Java. Le
programmeur doit lui-même lever ses exceptions
• Pour se faire Java met à sa disposition le mot- clé throw (à ne pas confondre avec throws).
Pour le reste (try, catch, finally) le mécanisme est identique
• Voici un exemple de création et d’utilisation d’une classe d’exceptions définie par le
programmeur:
Résumé

• Intérêts:

– Gérer systématiquement les exceptions

– Clarifier le code source

• Contraintes:

– Lourdeur de certaines parties du code

– Traitements ralentis