juin 2005 Brigitte Groléas 1
J300 (JHE)
Java : Héritage & Exceptions
~~ Brigitte Groléas ~~
juin 2005 Brigitte Groléas 2
Héritage - EST UN - Is A
Construire une classe à partir d'une autre classe Créer une classe comme 'spécialisation' d'une autre
classe plus générale
animal insectes reptiles mammifères mammifère
humains chiens chats
chiens neige traîneaux chasse
classe représente une forme de spécialisation d'une autre classe plus
générale
juin 2005 Brigitte Groléas 3
Dérivation
Une classe dérivée est une particularisation d'une classe de base
« class Etudiant extends Individu un étudiant est un Individu qui ....
« class Prof extends Individu un Prof est un Individu qui ....
Toutes les composantes sont héritéesToutes les composantes de la mère existent dans la fille
juin 2005 Brigitte Groléas 4
Masquage Si une composante de la mère est redéfinie dans
la fille : la composante de la mère est masquée par celle de la fille
super. permet de démasquer
la composante de la mère
class Derivee extends Base {public int a;public int i;public void toto()
{ ... }public void foobar()
{ ... }public void test() {
a = 10;i = 30;j = 40;super.i = 50;toto();foobar();foo();super.foobar();
} }
class Base {public int i;public int j;public void foo() { ... }
public void foobar() { ... }}
juin 2005 Brigitte Groléas 5
Visibilité
Mécanisme de protection dans l'héritage
protected : composantes de la classe de base qui seront inaccessibles à l'extérieur du package mais accessibles dans les classes dérivées et les classes du même package
Toutes les composantes sont héritéesToutes les composantes ne sont pas forcément accessibles
juin 2005 Brigitte Groléas 6
Résumé sur la visibilité des composantes
Attributs : public protected rien du tout
private
visibilitédescomposants
partout classe+sous classe
s +package
classe +
package
classe
juin 2005 Brigitte Groléas 7
Constructeurs
Construire les données propres à la mère
et construire les données propres à la fille
class Etudiant extends Individu {int numéro;int étude;
Etudiant( String n, String p, date d, int num, int etu ) {
super( n, p, d );numéro = num;étude = etu;
}}
class Etudiant extends Individu {int numéro;int étude;
Etudiant( String n, String p, date d, int num, int etu ) {
super( n, p, d );numéro = num;étude = etu;
}}
première instructionobligatoirement
juin 2005 Brigitte Groléas 8
Dériver ou ne pas dériver : voilà la
question
La dérivation est valide lorsque tous les objets de la sous-classe sont des objets de la super classe
neurones dérivent ou non en cellules ? chiens dérivent ou non en mammifères ?
mammifères dérivent ou non en animaux ?hommes dérivent ou non en cellules vivantes ?
... est un cas particulier de ... DERIVE... est un composé de ... NE DERIVE PAS
juin 2005 Brigitte Groléas 9
à vous ...
class Mere {private int a;public int b;
}class Fille extends Mere {
private int i;public int j;publicvoid foobar() {
a = 10; b = 20; i = 30; j = 40;
}
Que se passe t il ?
juin 2005 Brigitte Groléas 10
à vous ...
package toto;public class Mere {
private int a;protected int b;public int c;
}
package titi;public class Fille extends toto.Mere {void foobar(){
a = 10; b = 20; c = 30;
}}
package tutu;class Programme { public static void main( String args[] ) {
titi.Fille f = new titi.Fille(); f.a = 10;
f.b = 20; f.c = 30;
}}
Que se passe t il ?
juin 2005 Brigitte Groléas 11
class Etudiant extends Individu { … }
1. La classe Etudiant hérite de toutes les composantes publiques de la classe Individu
2. La classe Etudiant hérite uniquement des méthodes publiques de la classe Individu
3. En cas d'homonymie des fonctions entre Etudiant et Individu, les fonctions publiques de Individu sont écrasées par les fonctions de Etudiant.
4. En cas d'homonymie des fonctions entre Etudiant et Individu, les fonctions publiques de Individu sont masquées par les fonctions d‘Etudiant.
5. Une classe peut étendre plusieurs classes mères6. Dans une classe étendue, le programmeur doit
obligatoirement redéfinir les méthodes de la super classe
à vous ... Vrai ou faux
juin 2005 Brigitte Groléas 12
Programmation par concept
Une référence vs une instance un chien et un chat SONT DES Animaux
Chien et Chat dérivent de AnimalAnimal milou = new Chien();Animal titi = new Chat();
Les références polymorphes
juin 2005 Brigitte Groléas 13
La classe Object
Toutes les classes dérivent de la classe Object, mère de toutes les classes
Possibilité de manier un objet de n'importe quel type
return Object -> cast de la valeur retournée
Les classes final ne peuvent pas être dérivées
juin 2005 Brigitte Groléas 14
Vers l'abstraction
Des modèles fonctionnels Une classe abstraite est une classe qui exprime un
certain nombre de concepts fonctionnels certains sont concrets, d'autres sont encore abstraits.
Les fonctionnalités concrètes seront héritées Les fonctionnalités abstraites devront être
implémentées dans les classes filles
juin 2005 Brigitte Groléas 15
Mise en oeuvre Une classe abstraite
dispose d'au moins une fonctionnalité non encore concrétisée.
ne peut pas donner lieu à la création d'objet Les constructeurs et les méthodes statiques ne
peuvent pas être abstraitsabstract class Mere {
public abstract void foo() ;public abstract void bar() ;public void foobar() {
foo();bar() ;
}}
juin 2005 Brigitte Groléas 16
Exemple
abstract class Forme { private int xpos ; private int ypos; public abstract void efface(); public abstract void affiche(); public void deplace( int x, int y ) { efface();
xpos = x;ypos = y;affiche();
}}
class Cercle extends Forme { public void efface() {
// code de la méthode efface } public void affiche() {
// code de la méthode affiche } }
juin 2005 Brigitte Groléas 17
Abstraction Totale
Interface une sorte de classe spéciale abstraite
permet de définir un contrat d’interface fonctionnelle
C'est la définition d'un 'type'
toutes les méthodes sont implicitement « public » et « abstract »
toutes les composantes données sont implicitement « static » et « final »
alternative à l'héritage multiplealternative à l'héritage multiple
juin 2005 Brigitte Groléas 18
Définition
public interface perso{void f();
…}
public interface perso{ void f(); …}
public interface perso{ public static final int i = 10; void f(); …}
public interface perso{int j = 100;void f();
…}
juin 2005 Brigitte Groléas 19
Implémentation
class Truc implements Bidule {public void foo( int x ) {
// code concret de l’implémentation de la méthode foo()}public int bar( double d ) {
// code concret de l’implémentation de la méthode bar()}
} Une interface ne peut définir que des constantes
(final static).
juin 2005 Brigitte Groléas 20
La délégation pour simuler un héritage multiple
Une classe peut implémenter une ou plusieurs interfaces tout en dérivant d’une classe :
la dérivation représente la partie concrète, l'interface la partie fonctionnelle
class Truc extends Chose implements Bidule, Machin { // ...
}
class Truc EST UNE Chose QUI DISPOSE DES FONCTIONALITS DE Bidule, Machin
juin 2005 Brigitte Groléas 21
Références polymorphes
class Truc extends Chose implements Bidule, Machin { // concrétisation des méthodes de Bidule et Machin...
}class Truc2 extends AutreChose implements Bidule {
// concrétisation des méthodes de Bidule...}Bidule b1 = new Truc();Bidule b2 = new Truc2();b1.foo();
b2.foo();Ainsi on peut définir une référence sur l’interface
Bidule pour pointer un objet de la classe Truc
juin 2005 Brigitte Groléas 22
Dérivation d’interfaces
Une interface peut dériver d’une ou plusieurs autres interfaces, ainsi l’héritage multiple est possible pour les interfaces
interface Bidule { ...}interface Machin {... }interface Pouet extends Bidule, Machin {...}
juin 2005 Brigitte Groléas 23
Méthodologie d'analyse
Identifier les composantes des différentes classes
Repérer les composantes de sémantiques et d'implémentation communes ( -> classe mère)
Repérer les composantes de sémantique commune
(-> interface commune)
juin 2005 Brigitte Groléas 24
À vous … vrai ou faux
interface Bidule { void foo( int x ); }
Le terme implements permet d'utiliser l'interface Bidule dans la création d'une classe,
La méthode foo() est abstraite dans Bidule Si la classe Truc implémente Bidule, la
méthode foo(), devra obligatoirement être redéfinie dans Truc pour pouvoir instancier des objets
juin 2005 Brigitte Groléas 25
Illustration
Trier des ArrayList Problématique : les objets sont de nature
différentes Critère de tri -> Laisser le choix et imposer
le nom : interface Objet à trier -> Appel générique aux
données, utilisation de la référence commune à tous les objets
ArrayList list1 = new ArrayList();
Collections.sort(list1);
juin 2005 Brigitte Groléas 26
interface Comparable
public class Individu implements Comparable{.........public int compareTo(Object arg0) {
Individu e = (Individu)arg0;int i = nom.compareTo(e.nom);if( i==0 ){
int j = prenom.compareTo(e.prenom);
return j;}else return i;
}
La classe à trier doit implémenter Comparablepour définir la méthode de tri
juin 2005 Brigitte Groléas 27
Les Exceptions
Mécanisme permettant de traiter les comportements exceptionnels.
Constituent un moyen fiable et pratique d’effectuer un contrôle des erreurs rigoureux sans alourdir le code.
La notion d’erreur fait partie intégrante de la fonction
juin 2005 Brigitte Groléas 28
Principe de fonctionnement
Une exception : signal qui indique qu’une chose inhabituelle s’est
produite signal véhiculé par un objet (de type Throwable)
qui est lancé et se propage en remontant au travers de l’imbrication des blocs de code et les appels emboîtés de fonctions depuis sa source jusqu'à la méthode main()
C'est une instance d'une classe dérivant de la classe « java.lang.Throwable »
La classe « Throwable » possède 2 sous classes standards « Error » et « Exception ».
juin 2005 Brigitte Groléas 29
Les différentes exceptions
Les exceptions sous-classes de « Error » correspondent à des erreurs fatales (erreur d’édition de liens dynamique, plus de mémoire, ... ). Non controlées
Les exceptions sous-classes de « Exception » indiquent des erreurs non fatales qu’il convient de considérer en les capturant et en les traitant. Si une méthode est susceptible de générer une exception elle doit obligatoirement, soit capturer et traiter cette exception, soit la déclarer dans son entête par une clause
« throws » pour prévenir qu’elle ne la traite pas. Ce sont des exceptions contrôlées puisqu’il y a obligation de les traiter ou de les déclarer.
juin 2005 Brigitte Groléas 30
Les différentes exceptions
Les Exceptions sous-classes de RunTimeException indiquent des erreurs non fatales que le programmeur peut capturer et traiter, mais qui sont considérées comme omniprésentes (parce que trop courantes) et ne nécessitent pas de déclaration dans l’entête des méthodes qui ne les traitent pas. Ce sont des exceptions non contrôlées.
juin 2005 Brigitte Groléas 31
Les Exceptions de la classe Exception
ClassNotFoundExceptionCloneNotSuportedExceptionIllegalAccessExceptionInstantiationExceptionInterruptedExceptionNoSuchMethodeExceptionAWTException (java.awt)IOException (java.io)EOFException (java.io)FileNotFoundException (java.io)InterruptedIOException (java.io)UTFDataFormatException (java.io)MalformedURLException (java.net)ProtocolException (java.net)SocketException (java.net)UnknownHostException (java.net)UnknownServiceException (java.net)
Traitement obligatoire
juin 2005 Brigitte Groléas 32
Les Exceptions de la classe RuntimeException
ArithmeticExceptionArrayStoreExceptionClassCastExceptionIllegalArgumentExceptionIllegalThreadStateExceptionNumberFormatExceptionIllegalMonitorStateExceptionIndexOutOfBoundsExceptionArrayIndexOutOfBoundsExceptionStringOutOfBoundsExceptionNegativeArraySizeExceptionNullPointerExceptionSecurityExceptionEmptyStackException (java.util)NoSuchElementEception (java.util)
Traitement non obligatoire
juin 2005 Brigitte Groléas 33
Exceptions contrôlées : Clause throws
public void methode() throws UneException, UneAutreException {// corps de la méthode
}
Les méthodes utilisées déclarent des exceptions contrôlées dans leurs clauses « throws », il est impossible de les ignorer. Il faut avoir une stratégie pour les gérer
juin 2005 Brigitte Groléas 34
Traiter les exceptions
Capturer l’exception et la traiter. La méthode n’a plus à déclarer cette classe d’exceptions dans sa clause « throws » puisqu’elle a été traitée.
Capturer l’exception, ne pas la traiter (ou la traiter partiellement) et générer une nouvelle exception définie par le programmeur (via l’instruction throw). Il doit alors déclarer cette nouvelle classe d’exceptions dans la clause « throws » de sa méthode.
Ignorer l’exception dans le corps de sa méthode. Il faut alors déclarer cette classe d’exception dans la clause « throws » de sa méthode car elle est indirectement susceptible de générer ce type d’exceptions.
juin 2005 Brigitte Groléas 35
Capturer des Exceptions : try, catch
Pour capturer des exceptions public void methode() { try {
// instructions risquant de générer des Exceptions} catch( UneException e) {
// traitement des Exceptions de type UneException} catch( UneAutreException e) {
// traitement des Exceptions de type UneAutreException
}
juin 2005 Brigitte Groléas 36
La classe « Throwable »
méthodes héritées par toutes les sous-classes : String getMessage();
retourne le message standard associé à l’Exception ou l’Erreur.
void printStackTrace();
void printStackTrace( PrintStream flux )affiche une trace de la pile sur le flux qui montre où a eu lieu l’exception. Par défaut affiche sur « System.out ».
juin 2005 Brigitte Groléas 37
De toute façon : Clause finally
Si la clause « finally » est présente, son code est exécuté après le traitement de bloc « try » quelque soit la façon dont le traitement s’est achevé
public void methode() { // code avant le try try {
// instructions risquant de lever des Exceptions} ... } finally {
// code à effectuer quoi qu’il en soit} // code après le try}
juin 2005 Brigitte Groléas 38
Exceptions utilisateur
1. class PileException extends Exception {2. private int codeErreur;3. 4. public PileException( String mess, int
code ) {5. super( "Erreur Pile : " + mess );6. codeErreur = code;7. }8. public final int getErrorCode() {9. return codeErreur;10. }11. }
juin 2005 Brigitte Groléas 39
Lancer ses Exceptions : throw1. public class Pile {2. private int pile[]; private int sommet = 0;3. int ERR_VIDE = -1; int ERR_PLEINE = -2;4. 5. Pile( int taille) { 6. pile = new int[taille]);7. }8. void empile( int val ) throws PileException {9. if( sommet >= pile.lenght ) 10. throw new PileException( "Pleine", ERR_PLEINE);11. pile[sommet++] = val ;
}1. void int depile() throws PileException {
12. if( sommet < 1) 13. throw new PileException( "Vide", ERR_VIDE );14. return pile[--sommet];
1. }15. }
juin 2005 Brigitte Groléas 40
À vous … vrai ou faux
Si une exception n’est pas capturée par le bloc de code qui l’a générée, elle se propage vers le bloc directement entourant
toPrint permet d'obtenir un descriptif sommaire de l'exception
l'instruction throw permet de lancer une exception
La clause finally permet de passer outre les exceptions