Download - JAVA Chapitre5
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
1
MASTER PROFESSIONNEL
NOUVELLES TECHNOLOGIES DES TELECOMMUNICATIONS ET RESEAUX
(N2TR)
Cours JAVA © FST
Les Objets dans Java
Objectif :
Ce chapitre vous permettra de comprendre la notion d’objet en JAVA à travers l’encapsulation, le
polymorphisme et l’héritage. En plus il permettra d’assimiler les différents mécanismes de
déclarations d’une classe et comprendre comment gérer les erreurs au sein d'une application.
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
2
Sommaire Vocabulaires Objet .................................................................................................................................. 4
L'encapsulation : ...................................................................................................................................... 7
L'encapsulation de données ................................................................................................................ 7
L'encapsulation de méthodes ............................................................................................................. 8
Public et private ................................................................................................................................... 8
Les méthodes ...................................................................................................................................... 9
La création, la manipulation et la destruction d'objets : le mécanisme de ramasse-miettes (garbage
collector) ................................................................................................................................................ 11
La création d’objet ou constructeur .................................................................................................. 11
La destruction d'objets : le mécanisme de ramasse-miettes (garbage collector) ............................... 11
Les tableaux de valeurs ......................................................................................................................... 12
Les tableaux d'objets ............................................................................................................................. 13
L'organisation du code en packages ...................................................................................................... 13
Les niveaux de visibilité pour les classes et leurs membres .................................................................. 14
Les mécanismes objet avancés avec l'héritage et le polymorphisme ................................................... 14
Les différents types d'héritage .......................................................................................................... 16
Héritage simple :............................................................................................................................ 16
Héritage multiple : ......................................................................................................................... 16
L’utilisation de super ......................................................................................................................... 17
Redéfinition et réutilisation des constructeurs ................................................................................. 18
La méthode et la class final ............................................................................................................... 19
Le polymorphisme ............................................................................................................................. 20
La notion de composition ou agrégation ...................................................................................... 21
Les classes abstraites et les interfaces .................................................................................................. 22
Méthodes abstraites ......................................................................................................................... 22
Les classes abstraites ......................................................................................................................... 23
Les interfaces ..................................................................................................................................... 24
Mécanisme d'exceptions ....................................................................................................................... 25
Comment gérer les erreurs au sein d'une application ? ................................................................... 25
Qu’est ce qu’une exception ? ............................................................................................................ 26
Le principe de propagation des exceptions........................................................................................... 26
Les principales classes d'erreurs et d'exceptions .................................................................................. 26
Le traitement des exceptions avec les blocs try-catch-finally ............................................................... 27
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
3
La déclaration des exceptions (throws), cas des RuntimeException .................................................... 28
Cas des RuntimeException ................................................................................................................ 29
Développer des classes d'exception personnalisées ............................................................................. 29
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
4
Vocabulaires Objet
LES CLASSES : Une classe représente un modèle de construction d'un objet. Il s'agit d'une
description abstraite en termes de données et de comportements d'une famille d'objets. Une
classe d'objets est constituée d'une partie statique et d'une partie dynamique
Partie statique : LES ATTRIBUTS : Les attributs représentent la description des données
propres à chaque classe d'objets. Ceux-ci peuvent être des objets d'autres classes ou des
références sur d'autres objets. Pour qualifier les attributs d'une classe, on raisonnera en terme de
propriétés.
Partie dynamique : LES METHODES : Les méthodes représentent l'ensemble des actions,
procédures, fonctions ou opérations que l'on peut associer à une classe. L'ensemble des
méthodes de la classe définit le "COMPORTEMENT "
Objet = Etat + comportement + identité
INSTANCES DE CLASSES :
Une instance de classe est un élément construit selon le modèle de sa classe.
On nommera cet élément "OBJET".
L'opération par laquelle une classe produit plusieurs instances est l'instanciation
CONCEPTS D'ACTIVATION
Le seul mode de communication entre objets est l'envoi de messages.
Les messages : Un message est une requête. L'arrivée d'un message provoque l'exécution d'une méthode
d'un objet. Chaque message précise la méthode à appliquer avec éventuellement des paramètres. L'objet
destinataire est soit spécifié, soit implicite, si un objet appelle une de ses propres méthodes.
Message AFFICHE(vide) =>OBJET Carré =>
ou
Message AFFICHE(plein) => OBJET Carré =>
Une classe décrit un ensemble de « choses » abstraites et inexistantes (les attributs et les
méthodes).
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
5
Pour matérialiser une classe, on utilise les objets qui sont une représentation physique de la
classe et qui auront les propriétés définies de la classe, c'est-à-dire les attributs et les méthodes
de cette classe.
L’objet représente une instance de la classe.
Ce qui rend l’objet une représentation physique, c’est l’allocation de mémoire pour cet
objet.
Pour mieux comprendre la notion de class voici un exemple :
Soit la class voiture :
Voici un exemple d’instances de la classe voiture :
PEUGEOT 54S 3412 SM 59 130 Km /h 54 l 15 CV 120 DIN, ...
RENAULT ULTIMA V6 4954 VD 59
190 Km /h 62 l 23 CV 160 DIN, ...
Voiture _Peugeot
Peugeot :Marque
class Voiture
Attributs Méthodes
Marque
Modèle
Immatriculation
Vitesse
Niveaudecarburant
Puissancefiscale
PuissanceDIN
Etc ...
Démarrer
Accélérer
Freiner
Stopper
Vidanger
Etc ....
Nom de l’objet
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
6
54S :Modèle
3412 SM 59 :Immatriculation
130 Km /h :Vitesse
54 l :Niveaudecarburant
15 CV :Puissancefiscale
120 DIN :PuissanceDIN
Démarrer ( )
Accélérer ( )
Freiner ( )
D’abord pour utiliser un objet il faut le déclarer comme suit :
Voiture Voiture_Peugeot=new Voiture ( ) ;
Pour pouvoir utiliser un attribut d’une class, prenons l’exemple de l’initialisation :
Voiture_Peugeot.marque = " Peugeot " ;
Pour pouvoir appliquer une méthode de ma class Voiture :
Voiture_Peugeot. Démarrer ( ) ;
Mais dans ces exemples nous n’avons pas vu la déclaration réelle d’une class en Java, et pour
cela voici ce qu’il faut faire :
Parlons un peu de cette class Voiture :
Nous avons commencé par la déclaration de la classe, il faut savoir que le nom de la
classe commence par une majuscule et que le fichier ‘.Java’ doit avoir le même nom.
Les attributs
Les méthodes
public class Voiture
{
//déclaration des variables globales
String Marque,Modèle, Immatriculation,Vitesse;
String Niveaudecarburant,Puissancefiscale,PuissanceDIN ;
//faire appelle d’une class Moteur dans la class Voiture
Moteur motor = new Moteur ( ) ;
//déclaration du constructeur
public Voiture ( ){ }
//déclaration des méthodes
public void Démarrer ( ) { }
public void Accélérer ( ) { }
public void Freiner ( ) {
//déclaration d’une méthode de la class Moteur
motor.vidange( ) ;
}
}
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
7
Nous avons déclaré les attributs qui sont dans notre cas des variables globales et donc
toutes les méthodes pourront utiliser ces variables.
Nous avons fait appel d’une autre class Moteur à l’intérieur de la notre, il est à noter
que l’on peut faire appel à d’autres class selon le besoin.
Nous avons commencé par déclarer un constructeur avant les méthodes. Ce
constructeur sera exécuté dés l’appel de la classe même si on va ensuite faire appel à
l’une des méthodes de cette class, mais il est à noter que le constructeur est une
méthode.
Nous avons ensuite déclaré nos méthodes dans lesquelles les instructions demandées
seront exécutées.
Nous avons fait appel à une méthode d’une autre.
L'encapsulation :
L'encapsulation est un mécanisme consistant à rassembler les données et les méthodes au sein
d'une structure en cachant l'implémentation de l'objet, c'est-à-dire en empêchant l'accès aux
données par un autre moyen que les services proposés. L'encapsulation permet donc de
garantir l'intégrité des données contenues dans l'objet.
L'encapsulation de données L'encapsulation des données est une règle de microarchitecture (architecture détaillée)
consistant à cacher les données d’une classe ou d’un module aux autres classes ou modules,
c'est-à-dire, empêcher l'accès aux données par un autre moyen que des méthodes (fonctions
membres). Par conséquent, l’interface d’une classe ou d’un module obéissant à ce principe
n’expose jamais ces membres de données comme des variables, tableaux ou structures mais
seulement des méthodes (fonctions membres).
Exemple :
Méthode : Calcul de la clé d'un numéro de sécurité sociale
Objet : Individu (Assuré Social par exemple)
Donnée protégée : Valeur du modulo pour le calcul de clé
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
8
L'encapsulation de méthodes
L’encapsulation consiste donc à définir des étiquettes pour les méthodes afin de préciser si
celles-ci sont accessibles à partir d'autres classes ou non...
De cette manière, des données membres portant l'étiquette private ne peuvent pas être
manipulées directement par les méthodes des autres classes. Ainsi, pour pouvoir manipuler
ces données membres, le créateur de la classe (vous en l'occurrence) doit prévoir des
méthodes spéciales portant l'étiquette public, permettant de manipuler ces données.
Les fonctions membres permettant d'accéder aux données membres sont appelées accesseurs, parfois getter (appelation d'origine anglophone)
Les fonctions membres permettant de modifier les données membres sont appelées mutateurs, parfois setter (appelation d'origine anglophone)
On appelle généralement "interface" l'ensemble des méthodes permettant à l'utilisateur de
manipuler une classe.
Exemple :
Message = Débiter(somme, compte, code_confidentiel).
Objet = compte bancaire.
Méthode A (Visible depuis l'interface) = Débiter_carte_de_crédit.
Méthode B (non visible par l'utilisateur mais appelée par la méthode A) = Algorithme de
validation du code confidentiel.
Des méthodes encapsulées peuvent faire appel à des données qui sont elles-mêmes protégées
Public et private
Java définit quatre niveaux d'accès pour les variables d'instances (données membres) et les
méthodes :
public : un élément public est accessible de partout et sans aucune restriction.
Certaines classes (comme la classe principale main) doivent obligatoirement être
déclarées publiques (pour pouvoir exécuter l'application...)
protected : un élément protected (protégé) est accessible uniquement aux classes d'un
package et à ses classes filles
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
9
private : un élément private (privé) est accessible uniquement au sein de la classe
dans laquelle il est déclaré. Ces éléments ne peuvent être manipulés qu'à l'aide de
méthode spécifiques appelés accesseur et mutateur
"friendly" : un élément est friendly par défaut (cette appellation n'est pas officielle et
est empruntée au langage C++) est accessible uniquement aux classes d'un package et
à ses classes filles.
final précise que la valeur de la variable ou class ou méthode ne pourra plus être
changée après son affectation initiale.
Les méthodes
On peut définir les méthodes comme des fonctions propres à la class qui permettra de réaliser
les instructions demandées dans cette dernière.
La méthode doit s’écrire de la manière suivante :
public static void
methodeA(String[] args){
type1 ;
type2 ;
Class1 c= new Class1 ( );
...
type N;
instruction 1;
instruction 1;
resultat=c.methodeB();
...
instruction N;
return;
}
Déclaration de la méthode
Déclaration des variables et
appel de class extérieure
Déclaration d’instructions
Appel d’une méthode
externe de notre class
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
10
On trouve deux types (familles) de méthodes
Les fonctions ayant un type (int, String,…) et qui vont retourner une réponse de même
type que leur déclaration
Les procédures se déclarent par void et n’ont pas de valeur de retour.
Dans la déclaration de la méthode selon le besoin on peut déclarer les arguments qui devront
être utilisés par la méthode.
Après avoir déclaré la méthode, il faut déclarer les variables qui seront utilisées dans cette
méthode, on peut aussi faire appel à d’autres class.
Remarque : les variables peuvent être déclarées à n’importe quel niveau de la méthode.
Et, enfin on a posé les instructions.
Voici un exemple maintenant d’une méthode à l’intérieur d’une class :
Remarque : En Java, deux méthodes peuvent avoir le même nom c’est ce qu’on appelle
surcharge mais, lors de l’exécution les méthodes sont différenciées avec leurs arguments.
public class Afficher{ public static void main (String() args){ for(int i=0;i<=5;i++)
{ System.out.pintln(“valeur de I”+i); If(i==3){ Break; } }
}
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
11
La création, la manipulation et la destruction d'objets : le mécanisme
de ramasse-miettes (garbage collector)
Une classe a un cycle de vie unique : création « vivre », manipulation (réaliser le traitement
attendu) et la destruction « mourir », donc pour résumer : une classe se compose
principalement d’un constructeur, de méthodes, et de destructeur.
La création d’objet ou constructeur
Cette méthode permet généralement d'assigner des valeurs aux variables définies dans la
classe. Cette méthode obéit toutefois à des règles particulières :
Un constructeur doit toujours être une méthode publique
On doit impérativement donner le même nom que votre classe au constructeur
Un constructeur ne retourne rien.
On ne doit pas mettre de void, même si le constructeur ne retourne rien.
Si, on n’écrit pas un constructeur, un constructeur est fourni automatiquement. Ce
dernier ne prend aucun argument et son corps est vide.
Exemple de construction :
La destruction d'objets : le mécanisme de ramasse-miettes (garbage collector)
Le destructeur est une méthode spéciale qui sera appelée (si elle est redéfinie dans la classe)
lorsque l'objet sera nettoyé de la mémoire par le garbage collector.
Le garbage collector est un "ramasse-miettes" chargé de faciliter la tâche des programmeurs
en libérant les ressources prises en mémoire automatiquement. Cette méthode n'est pas
forcément appelée lorsque vous supprimez l'objet.
Pour utiliser le destructeur on doit redéfinir une méthode appelée finalize() publique et qui ne
renvoie rien.
public class Test
{
private int i;
private boolean condition;
public Test()
{
i = 0;
condition = false;
System.out.println("La construction est realiser");
}
}
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
12
Exemple de destruction :
Les tableaux de valeurs
L'utilisation d'un tableau permet d'avoir à sa disposition un très grand nombre de variables en
utilisant un seul nom.
Pour déclarer un tableau en Java nous devons d’abord déclarer le type du tableau ensuite le
type des variables contenues dedans.
Voici un exemple de déclaration de tableau :
Exemple d’utilisation d’un tableau :
public void finalize()
{
System.out.println("mémoire nettoyer");
}
int[] tab ;
tab = new int[20];
OU
int[] tab = new int[20];
Déclarer le type du tableau
Déclarer le type des variables
Fixer la taille du tableau
Class Tableau { String [] tab=new String [2] ; public static void main(String[] args) { tab*1+ = ”a”; System.out.println( tab[1] ); } }
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
13
Les tableaux d'objets
Le tableau d’objet permet de retourner un objet qui sera un tableau, ce qui fait que lorsqu’on
va déclarer notre objet, il sera de type tableau avec le type de ce tableau.
Voici un exemple pour mieux comprendre :
L'organisation du code en packages
Les « packages » représentent les chemins où se trouvent les classes.
Comme nous l’avons indiqué précédemment, chaque classe est déclarée dans un fichier, ces
classes (fichiers) sous un ou plusieurs répertoires, les classes qui sont sous un même répertoire
sont dans un paquetage « package ».
Le nom d’un package est formé du chemin où se trouvent les (ou la) classes.
Lors de la déclaration du package, les noms des « répertoires » (le chemin) sont séparés par
un point ".".
Exemple de déclaration du package :
package com.fst.application.app1;
Schéma du package au niveau du projet Chemin sur disque
Remarque : le nom d’un package doit obligatoirement commencer par une minuscule.
static int[] copier(int[] x){
int n = x.length;
int[] y = new int[n];
for(int i = 0; i < n; i++)
y[i] = x[i];
return y;
}
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
14
Les niveaux de visibilité pour les classes et leurs membres
On trouve 3 niveaux de visibilité pour les classes et leurs membres: public, protected, et
private.
private, la variable ou la méthode ne peuvent être visible que dans leur classe mère.
protected, la variable ou la méthode sont visibles dans leur classe mère ainsi que dans
ses classes dérivées (qui héritent de la classe mère).
public, la variable ou la méthode sont visibles dans tout le code dès qu’on fait appel à
leur classe.
Remarque : on peut aussi ajouter un autre niveau de visibilité, le package, car avec l’appel
d’un package on peut utiliser ses classes sans avoir besoin de les importer.
Les mécanismes objet avancés avec l'héritage et le polymorphisme
L'héritage est un mécanisme destiné à exprimer les similitudes entre classes. Il met en œuvre
les principes de généralisation et de spécialisation en partageant explicitement les attributs et
méthodes communs au moyen d'une hiérarchie de classes.
Ainsi grâce à l’héritage on gagne en rapidité et facilité de traitement.
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
15
L'héritage est un mécanisme qui permet de créer une nouvelle classe à partir d'une autre classe
qui existe déjà, avec ce mécanisme la classe fille hérite des propriétés et des méthodes de la
classe mère, c'est-à-dire que la classe fille peut utiliser et modifier les attributs et les méthodes
de la classe mère selon ses besoins, comme si on avait besoin de faire un traitement mais ce
dernier existe déjà, alors au lieu de refaire tout le code on hérite de la classe qui possède ce
traitement et on l’utilise.
La classe fille hérite des caractéristiques de sa classe mère (attributs et méthodes) mais elle se
distingue par ses caractéristiques propres.
ou classe mère, méta classe, classe de base, ancêtre
Lien d'héritage
ou classe fille, classe dérivée, descendant
Voici un exemple pour mieux comprendre :
public class A { public void Bonjour ( ) {
System.out.println(« Bonjour ») ; }
}
public class B extends A {
public void Salut ( ) { System.out.println(« Salut »);
} }
public class C extends B {
Public void Bye ( ) { System.out.println(«Bye ») ;
} }
extends permet a un classe fille
d’hériter les caractéristiques de la
classe mère.
Class A la classe mère
Class B et C les classes filles
C cobjet = new C () ; cobjet.Bye () ; => Bye cobjet.Salut () ; => Salut cobjet.Bonjour () ; => Bonjour
B bobjet = new B() ; bobjet.Bye () ; => Bye
La class B n’hérite pas de la class C
bobjet.Salut () ; => Salut bobjet.Bonjour () ; => Bonjour
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
16
Les différents types d'héritage
Héritage simple : une classe fille n'a qu'une seule classe mère et elle hérite d'une partie des
attributs et méthodes de celle-ci en ayant ses spécifications propres.
Héritage multiple : une classe fille hérite de plusieurs classes mères. Elle hérite d'une partie
des attributs et des méthodes de chacune de ses classes mères, en plus de ses spécifications
propres.
Exemple général : Création et réalisation d’une instance de class
Soit la Class A avec la mèthode Void ecriture et la Class B la la mèthode Main()
La class B affiche les messages « Bonjour Mr » et « Au revoir Ami » et sachant que la class
A contient une chaine « Bonjour ».
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
17
Lors d’un héritage, une classe fille peut redéfinir une des méthodes de la classe mère, mais il
ne faut pas confondre entre redéfinition et surcharge d’une méthode.
Dans la surcharge on a le nom d’une méthode qui se répète mais les arguments des
deux méthodes sont différents.
Dans la redéfinition on a le nom et les arguments d’une méthode qui se
répètent mais les instructions de la méthode diffèrent.
L’utilisation de super Pour faire appel aux fonctions de la classe mère on peut utiliser la notion de super qui fait
référence à la classe mère
Avec la fonction super on peut réutiliser une méthode d’une classe mère ou même la
redéfinir,.
Exemple : super.methode ( ) ;
class A { String chaine = “Bonjour”; void A (new chaine){ System.out.print ( chaine); System.out.println ( new chaine);
} } class B { A abojet = new A( ); aobjet.A(“Mr”); aobjet.chaine(“ Au revoir ”);
aobjet.A(“ Ami ”); }
Résultat :
Bonjour Mr
Au revoir Ami
public class A { public void affiche () { System.out.print (“Bonjour ”) ;
System.out.print (“Mr. ”); } }
Le résultat de la class A par
la méthode affiche :
Bonjour Mr.
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
18
Redéfinition et réutilisation des constructeurs
Souvent on fait appel à un constructeur d’une class mère pour une class fille et selon le besoin
soit, on la redéfinit soit, on la réutilise pour initialiser des valeurs.
Dans ce cas nous allons utiliser : super (paramètres du constructeur) ;
Exemple :
Comme vous pouvez le voir l’appel du constructeur est toujours la première instruction.
Remarque :
si le constructeur n’a pas d’arguments on aura super( ) ; .
Dans un héritage on peut aussi redéfinir les attributs, exemple :
public class B extends A {
String sportPratiqué ;
Public void affiche () { super.affiche() ;
System.out.println(“BOUHOUCHI ” ); } }
Le résultat de la class B par la
méthode affiche ( ) appelée
par super de la class A:
Bonjour Mr.
BOUHOUCHI
public class Point { double x, y ;
public Point (double x, double y) { this.x = x ; this.y = y ; } }
public class PointCouleur extends Point { Color c; public PointCouleur (double x, double y, Color c) { super(x, y) ; this.c = c ; } }
super fait appel au
constructeur Point
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
19
La méthode et la class final
final est utilisé pour verrouiller une méthode ainsi lorsqu’une class fille va l’hériter d’une
class mère, elle ne sera pas redéfinie, exemple :
On peut aussi utiliser final pour que la class déclarée ne soit plus héritée et devient une sous
class, de plus toutes les méthodes de cette class seront aussi final par défaut, exemple :
Les bénéfices de l’héritage :
Grace à l’héritage :
réutiliser un code.
partager un code.
gagner du temps, de l’espace mémoire et facilite les traitements.
selon un besoin, un code peut être modifié, et grâce à l’héritage on n’a pas besoin de
refaire tout le code.
public class ClasseA { int x ; }
public class ClasseB extends ClasseA { double x ; }
public class ClasseC extends ClasseB { float x ; }
L’attribut x de la class C hérité de B
est devenu de type réel.
L’attribut x de la class B hérité de A
est devenu de type double.
public final void A( ) { }
public final class B { }
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
20
Le polymorphisme
Le polymorphisme permet de définir plusieurs formes pour une méthode commune à une
hiérarchie d'objets. C'est à l'exécution que l'on détermine quelle forme appeler suivant la
classe de l'objet courant.Un code qui n'utiliserait pas le polymorphisme pourrait utiliser une
instruction à choix multiple suivant la classe des objets rencontrés.
Voici un exemple pour mieux comprendre :
class A {
public static void message ( ) { System.out.println(“ bonjour “) ; }
} class B extends A {
public static void message ( ) { System.out.println(“ Mr “) ; }
} class C extends B {
public static void message ( ) { System.out.println(“ BOUHOUCHI“) ; } Public static void main(String() args){ A aobjet = new A ( ) ; B bobjet =new B ( ) ; C cobjet =new C ( ) ; aobjet.message(); bobjet.message(); cobjet.message(); }
}
Résultat de la méthode main : Bonjour Mr BOUHOUCHI
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
21
Sur toutes ces classes, on a recours à la méthode message ( ). Le polymorphisme permet alors
d'appeler la bonne méthode selon le type d'objet.
La notion de composition ou agrégation
La composition consiste à réunir des objets pour en former un autre.
Dans le cas d'une composition (ou agrégation), on s'attachera à préciser le cardinal de cette
relation.
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
22
Les classes abstraites et les interfaces
Méthodes abstraites
Une méthode abstraite est une méthode déclarée dans une classe mais, sera définie dans une
sous classe.
Cette méthode sera déclarée comme suit :
Il faut mettre public(ou protected) abstract pour déclarer une méthode abstraite,
ensuite son type, puis son nom.
La méthode abstraite ne contient pas de code.
Selon le besoin on peut faire appel à une méthode abstraite dans une classe, ou dans une
méthode.
Exemple :
public abstract nomDelaClasse( ){
//il n’y a aucun codes dans la
méthode abstraite
}
public abstract class A {
private int i=5 ;
public abstract void Afficher(int somme ) ;
public void Calculer ( ) {
int somme ;
somme = i+5 ;
afficher( int somme ) ;
}
}
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
23
Les classes abstraites
Une classe abstraite est une classe qui contient au moins une méthode abstraire. Cette classe
ne peut être instanciée.
Exemple :
La classe abstraite s’écrit sous la forme suivante : abstract class NomDeClasseAbstraite {}.
Une classe abstraite peut contenir des méthodes non abstraites et des variables ordinaires
Voici un exemple pour mieux comprendre :
public abstract class A {
private int i=5 ;
public abstract void Afficher(int somme ) ;
public void Calculer ( ) {
int somme ;
somme = i+5 ;
afficher( int somme ) ;
}
}
abstract public class Analyse{
double X,Y;
void saisirVariable(double x,double y) {
X=x;
Y=y;
}
void afficherPosition(double X,double Y) {
System.out.println("les variables sont : "+X+","+Y+);
}
abstract double multiplication (double x,double y) ;
abstract double addition (double x,double y) ;
}
public class Calcul1 extends Analyse
{double multiplication(double x,double y){
return x * y;
}
double addition(double x,double y){
return x + y;
}
}
public class Calcul2 extends Analyse
{
double multiplication(double x,double
y){
return x/2 * y/2;
}
double addition(double x,double y){
return x/2 + y/2;
}
}
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
24
Les interfaces
Une interface est une classe complètement abstraite, toutes ses méthodes doivent être
abstraites, ses variables sont statiques et finales, les méthodes sont public et abstract.
Exemple :
Remarque :
une classe peut implémenter plusieurs interfaces.
Les interfaces peuvent hériter les unes des autres et peuvent redéfinir les méthodes
héritées.
Une classe qui implémente une interface doit définir le corps de toutes ses méthodes
abstraites
Pour mieux comprendre voici un exemple:
public interface A {
final static double x,y;
public void saisirVariable(double x,double y);
public void afficherPosition(double x,double y);
public double multiplication (double x,double y);
public double addition (double x,double y) ;
}
public class B implements A {
public void saisirVariable(double x,double y){
X=x;
Y=y;}
public void afficheMessage(double X,double Y) {
System.out.println("les variables sont : "+X+","+Y+);}
public double addition (double x,double y) {
return x + y;}
public double multiplication(double x,double y){
return x * y;}
}
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
25
Mécanisme d'exceptions
Comment gérer les erreurs au sein d'une application ? Nous allons commencer par un exemple :
Soit, l’équation mathématique suivante A=B / C qui est une application qui permet de
diviser la valeur B par C puis de l’affecter à A. Plusieurs erreurs peuvent se présenter :
C = 0
A, B, C ne sont pas de mêmes types (B et C float et A integer par exemple)
Etc. …
L’opération de division ne pourra pas s’effectuer avec ces différentes erreurs.
En Java ce type d’erreurs on les appelle les exceptions.
Exemple :
public class TestException {
public static void main(String( ) args) {
int i = 3;
int j = 0;
System.out.println("résultat = " + (i / j));
}
}
Exception in thread "main" Java.lang.ArithmeticException: / by zero
at tests.TestException.main(TestException.Java:23)
Résultat de l’exécution avec sortie du programme
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
26
Qu’est ce qu’une exception ?
Les exceptions sont des erreurs qui surgissent au cours du programme et arrêtent l’exécution
du programme, erreurs de type X/0, connexion interrompue, conversion d’une chaine de
caractères en entier « parseInt("a") »…
Au niveau de JAVA nous avons la possibilité de gérer ces exceptions.
Mécanisme de gestion : deux méthodes se présentent soit capturer et traiter l’exception (avec
try et catch), soit la lever ou propager (avec throw(s)).
Remarque :
Lever une exception consiste à signaler l’exception.
Capturer l'exception consiste à essayer de la traiter.
Le principe de propagation des exceptions
Soit une exception déclarée dans une application, si cette exception n’est pas immédiatement
capturée ou levée par un bloc catch, celle-ci se propage en remontant la pile d'appels des
méthodes, jusqu'à être traitées.
Si, cette exception n'est jamais capturée ou levée, elle se propage jusqu'à la méthode main(),
ce qui pousse l'interpréteur Java à afficher un message d'erreurs et à s'arrêter.
L'interpréteur Java affiche un message permettant d’identifier :
l'exception,
la méthode qui l'a causée,
la ligne correspondante dans le fichier.
Les principales classes d'erreurs et d'exceptions
Voici un schéma qui représente l’hiérarchie des exceptions :
Object
Throwable
Autres
Error
Exception
RunTimeException
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
27
La classe Exception et Error hérite de La classe Throwable.
La classe Throwable définit un message de type String qui est hérité par toutes les classes
d'exceptions. Ce champ est utilisé pour stocker le message décrivant l'exception.
Remarque : Ce message peut être récupéré par la méthode getMessage().
Nous avons donc :
Object
Throwable :Classe de base de toutes les exceptions.
Error : Erreurs graves (dont les exceptions asynchrones) qu'il n'est pas
raisonnable de vouloir intercepter.
Exception : Exceptions méritant d'être interceptées et traitées
RuntimeException : Exceptions pouvant survenir durant le
fonctionnement normal de la machine Java :
indice de tableau hors bornes
accès à un membre d'une référence null
erreur arithmétique, etc.
Voici quelques exceptions prédéfinies :
Division par zéro pour les entiers : ArithmeticException
Référence nulle : NullPointerException
Le traitement des exceptions avec les blocs try-catch-finally
Commençons par la syntaxe :
Le bloc try permet d’exécuter des instructions avec succès jusqu'à la fin du bloque si il n’y a
pas d’exception qui s’est levée.
try { ... } catch (<une-exception>) { ... } catch (<une_autre_exception>) { ... } ... finally { ... }
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
28
Les blocs catch permettent de récupérer l’exception et de vérifier si l’une d’entre elles peut
la traiter ou pas, si ils ne le peuvent pas, le programme peut être arrêté ou bloqué par
l’interpréteur Java.
Le bloc finally permet de définir un ensemble d'instructions qui seront toujours exécutées,
que l'exception soit levée ou non, capturée ou non.
Exemple :
La déclaration des exceptions (throws), cas des RuntimeException
Avec le mot réservé throw non pouvons lever (définir ou signaler) une exception.
Throw prend en paramètre un objet instance de Throwable ou d'une de ses sous-classes.
Une méthode susceptible de lever une exception est identifiée par le mot-clé throws suivi du
type de l'exception.
Exemple : Dans cet exemple l’exception sera seulement propagée.
Public class Exeption{ public static void main(String() args){ String test =”005” ; try{ System.out.println(“ valeur de A est” +test); } catch (NullPonterException N){ System.out.println(“ erreur“ ); } } }
private void analyseTerme() throws SyntaxException
{
if (texte.PremierCar() == '(')
{ texte.caractereSuivant();
analyseSomme();
if (texte.PremierCar() != ')')
throw new SyntaxException();
texte.caractereSuivant();
}
else
{ analyseChiffre();
return;
}
}
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
29
Pour lever l’exception, voici un autre exemple(*) :
Cas des RuntimeException
Les exceptions des RuntimeException sont des exceptions et des erreurs prédéfinies et/ou
gérées par Java.
Comme on vient de le voir dans le dernier exemple(*) nous avons utilisé l’exception
prédéfinie ArithmeticException de RuntimeException.
Développer des classes d'exception personnalisées
Pour générer une exception, il suffit d'utiliser le mot clé throw, suivi d'un objet dont la classe
dérive de Throwable. Si l'on veut générer une exception dans une méthode avec throw, il faut
l'indiquer dans la déclaration de la méthode, en utilisant le mot clé throws.
Selon notre besoin, on peut créer nos propres exceptions. Elles héritent des classes Exception
et non pas de la classe Error.
public class Equation {
int a=0;
int b=2;
int solution() throws ArithmeticException {
if (a = = 0)
throw new ArithmeticException( "division entière par zéro");
else
return b/a;
}
}
Chapitre5 : Les Objets dans Java
Riadh BOUHOUCHI
30
Exemple :
public class SaisieErroneeException extends Exception {
public SaisieErroneeException() {
super();
}
public SaisieErroneeException(String s) {
super(s);
}
}
public class TestSaisieErroneeException {
public static void controle(int i) throws SaisieErroneeException {
if (i == 0)
throw new SaisieErroneeException("Erreur de dvision par 0");
}
public static void main(String() args) {
int i=0;
int j=10;
try {
controle(i);
int div = j / i ;
}
catch (SaisieErroneeException e) {
System.out.println("l’entier saisie est erroné"+i);
};
}
}