Java : Héritage & Exceptions J300 (JHE) Java : Héritage & Exceptions ~~ Brigitte Groléas ~~ juin 2005 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 juin 2005 Brigitte Groléas

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ées Toutes les composantes de la mère existent dans la fille juin 2005 Brigitte Groléas

la composante de la mère 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 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() { ... } } super. permet de démasquer la composante de la mère juin 2005 Brigitte Groléas

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ées Toutes les composantes ne sont pas forcément accessibles juin 2005 Brigitte Groléas

Résumé sur la visibilité des composantes Attributs : public protected rien du tout private visibilité des composants partout classe+ sous classes + package classe + package classe juin 2005 Brigitte Groléas

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; } première instruction obligatoirement juin 2005 Brigitte Groléas

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 ... est un cas particulier de ... DERIVE ... est un composé de ... NE DERIVE PAS 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 ? juin 2005 Brigitte Groléas

à vous ... class Mere { private int a; public int b; } class Fille extends Mere { private int i; public int j; public void foobar() { a = 10; b = 20; i = 30; j = 40; Que se passe t il ? juin 2005 Brigitte Groléas

à vous ... package titi; public class Fille extends toto.Mere { void foobar(){ a = 10; b = 20; c = 30; } package toto; public class Mere { private int a; protected int b; public int c; } Que se passe t il ? 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; } juin 2005 Brigitte Groléas

class Etudiant extends Individu { … } à vous ... Vrai ou faux class Etudiant extends Individu { … } La classe Etudiant hérite de toutes les composantes publiques de la classe Individu La classe Etudiant hérite uniquement des méthodes publiques de la classe Individu En cas d'homonymie des fonctions entre Etudiant et Individu, les fonctions publiques de Individu sont écrasées par les fonctions de Etudiant. En cas d'homonymie des fonctions entre Etudiant et Individu, les fonctions publiques de Individu sont masquées par les fonctions d‘Etudiant. Une classe peut étendre plusieurs classes mères Dans une classe étendue, le programmeur doit obligatoirement redéfinir les méthodes de la super classe juin 2005 Brigitte Groléas

Programmation par concept Une référence vs une instance un chien et un chat SONT DES Animaux Chien et Chat dérivent de Animal Animal milou = new Chien(); Animal titi = new Chat(); Les références polymorphes juin 2005 Brigitte Groléas

Les classes final ne peuvent pas être dérivées 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

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

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 abstraits abstract class Mere { public abstract void foo() ; public abstract void bar() ; public void foobar() { foo(); bar() ; } juin 2005 Brigitte Groléas

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

alternative à l'héritage multiple 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 multiple juin 2005 Brigitte Groléas

Définition public interface perso{ 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

Une interface ne peut définir que des constantes 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

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

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

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

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

interface Bidule { void foo( int x ); } À 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

Illustration ArrayList list1 = new ArrayList(); 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 Collections.sort(list1); juin 2005 Brigitte Groléas

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 Comparable pour définir la méthode de tri juin 2005 Brigitte Groléas

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

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

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

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

Les Exceptions de la classe Exception ClassNotFoundException CloneNotSuportedException IllegalAccessException InstantiationException InterruptedException NoSuchMethodeException AWTException (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

Les Exceptions de la classe RuntimeException ArithmeticException ArrayStoreException ClassCastException IllegalArgumentException IllegalThreadStateException NumberFormatException IllegalMonitorStateException IndexOutOfBoundsException ArrayIndexOutOfBoundsException StringOutOfBoundsException NegativeArraySizeException NullPointerException SecurityException EmptyStackException (java.util) NoSuchElementEception (java.util) Traitement non obligatoire juin 2005 Brigitte Groléas

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

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

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

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

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

Exceptions utilisateur class PileException extends Exception { private int codeErreur;   public PileException( String mess, int code ) { super( "Erreur Pile : " + mess ); codeErreur = code; } public final int getErrorCode() { return codeErreur; juin 2005 Brigitte Groléas

Lancer ses Exceptions : throw public class Pile { private int pile[]; private int sommet = 0; int ERR_VIDE = -1; int ERR_PLEINE = -2;   Pile( int taille) { pile = new int[taille]); } void empile( int val ) throws PileException { if( sommet >= pile.lenght ) throw new PileException( "Pleine", ERR_PLEINE); pile[sommet++] = val ; void int depile() throws PileException { if( sommet < 1) throw new PileException( "Vide", ERR_VIDE ); return pile[--sommet]; juin 2005 Brigitte Groléas

À 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 juin 2005 Brigitte Groléas