Juin 2005Brigitte Groléas 1 J300 (JHE) Java : Héritage & Exceptions Brigitte Groléas

juin 2005 Brigitte Groléas 1

J300 (JHE)

Java : Héritage & Exceptions

~~ Brigitte Groléas ~~


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


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


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() { ... }}


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


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


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


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


à 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 ?


à 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 ?


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


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


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


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


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

}}


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 } }


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


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

…}


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


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


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


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 {...}


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)


À 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


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);


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


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


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 ».


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.


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.


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


Les Exceptions de la classe RuntimeException

ArithmeticExceptionArrayStoreExceptionClassCastExceptionIllegalArgumentExceptionIllegalThreadStateExceptionNumberFormatExceptionIllegalMonitorStateExceptionIndexOutOfBoundsExceptionArrayIndexOutOfBoundsExceptionStringOutOfBoundsExceptionNegativeArraySizeExceptionNullPointerExceptionSecurityExceptionEmptyStackException (java.util)NoSuchElementEception (java.util)

Traitement non obligatoire


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


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.


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

}


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 ».


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}


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. }


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. }


À 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

Documents

Juin 2005Brigitte Groléas 1 J300 (JHE) Java : Héritage & Exceptions ~~ Brigitte Groléas ~~

Juin 2005Brigitte Groléas 1 J300 (JHE) Java : Héritage & Exceptions Brigitte Groléas