SlideShare une entreprise Scribd logo
1  sur  30
Télécharger pour lire hors ligne
Chapitre5 : Les Objets dans Java




                     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.




                                                                                                   1
Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java


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


                                                                                                                                                                2
Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java


La déclaration des exceptions (throws), cas des RuntimeException .................................................... 28
   Cas des RuntimeException ................................................................................................................ 29
Développer des classes d'exception personnalisées............................................................................. 29




                                                                                                                                                  3
Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java




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


                                                                                                          4
   Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java


        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 :


                        class Voiture
                        Attributs               Méthodes
                        Marque                  Démarrer
                        Modèle                  Accélérer
                        Immatriculation         Freiner
                        Vitesse                 Stopper
                        Niveaudecarburant       Vidanger
                        Puissancefiscale        Etc ....
                        PuissanceDIN
                        Etc ...




        Voici un exemple d’instances de la classe voiture :




        PEUGEOT                                             RENAULT
        54S                                                 ULTIMA V6
        3412 SM 59                                          4954 VD 59
        130 Km /h                                           190 Km /h
        54 l                                                62 l
        15 CV                                               23 CV
        120 DIN, ...                                        160 DIN, ...




Nom de l’objet                                  Voiture _Peugeot
                                                Peugeot :Marque
                                                                                                                5
        Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java


                                                  54S :Modèle
                                         3412 SM 59 :Immatriculation
                                              130 Km /h :Vitesse                               Les attributs
                                           54 l :Niveaudecarburant
                                            15 CV :Puissancefiscale
                                           120 DIN :PuissanceDIN

                                                 Démarrer ( )
                                                 Accélérer ( )
                                                  Freiner ( )
Les méthodes



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


      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.

                                                                                                          6
      Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java


      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é




                                                                                                  7
Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java


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

                                                                                               8
Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java


                   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){                                   Déclaration des variables et
                                                                                            appel de class extérieure
Déclaration de la méthode                type1 ;
                                         type2 ;
                                         Class1 c= new Class1 ( );
                                         ...
                                         type N;
                                         instruction 1;
                                         instruction 1;
                                         resultat=c.methodeB();
                                         ...                                                Appel d’une méthode
                                         instruction N;
                                         return;
                                                                                            externe de notre class
Déclaration d’instructions
                                   }




                                                                                                                    9
            Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java


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 :


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




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.




                                                                                                 10
Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java


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 :


   public class Test
   {
     private int i;
     private boolean condition;

       public Test()
       {
         i = 0;
         condition = false;

           System.out.println("La construction est realiser");
       }
   }



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.

                                                                                                   11
Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java



        Exemple de destruction :


                      public void finalize()
                        {
                           System.out.println("mémoire nettoyer");
                        }



        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 :



                                                int[] tab ;
                                                tab = new int[20];
    Déclarer le type du tableau
                                                           OU
                                                                                       Fixer la taille du tableau
                                                int[] tab = new int[20];



Déclarer le type des variables




        Exemple d’utilisation d’un tableau :

                                      Class Tableau {
                                              String [] tab=new String [2] ;
                                              public static void main(String[] args)
                                               {
                                                 tab*1+ = ”a”;
                                                 System.out.println( tab[1] );
                                              }
                                      }




                                                                                                            12
        Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java


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 :


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




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.


                                                                                                    13
Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java


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.




                                                                                                    14
Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java


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 :

                             Class A la classe mère
 public class A {
                                                                     extends permet a un classe fille
          public void Bonjour ( ) {
            System.out.println(« Bonjour ») ;                        d’hériter les caractéristiques de la
           }                                                         classe mère.
      }


                                                                    C cobjet = new C () ;

                                                                    cobjet.Bye () ; => Bye
 public class B extends A {                                         cobjet.Salut () ; => Salut
                                                                    cobjet.Bonjour () ; => Bonjour
          public void Salut ( ) {
            System.out.println(« Salut »);
          }
  }                                                                   B bobjet = new B() ;

                                 Class B et C les classes filles      bobjet.Bye () ; => Bye

                                                                         La class B n’hérite pas de la
public class C extends B {
                                                                                    class C
          Public void Bye ( ) {
            System.out.println(«Bye ») ;                              bobjet.Salut () ; => Salut
           }                                                          bobjet.Bonjour () ; => Bonjour
  }
                                                                                                            15
Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java




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




                                                                                                   16
Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java



class A {
         String chaine = “Bonjour”;
                                                                                  Résultat :
         void A (new chaine){
                                                                                      Bonjour Mr
                 System.out.print ( chaine);
                 System.out.println ( new chaine);
         }
}                                                                                         Au revoir Ami



class B {
         A abojet = new A( );
         aobjet.A(“Mr”);
         aobjet.chaine(“ Au revoir ”);

        aobjet.A(“ Ami ”);

}




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



                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.




                                                                                                          17
    Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java



            public class B extends A {

                    String sportPratiqué ;
                                                                         Le résultat de la class B par la
                    Public void affiche () {
                    super.affiche() ;                                    méthode affiche ( ) appelée
                    System.out.println(“BOUHOUCHI ” );                   par super de la class A:
                    }
            }                                                            Bonjour Mr.

                                                                          BOUHOUCHI


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 :



    public class Point {
            double x, y ;
             public Point (double x, double y) {
                                                     public class PointCouleur extends Point {
                     this.x = x ;
                                                       Color c;
                     this.y = y ;
                                                       public PointCouleur (double x, double y, Color c) {
      }
                                                          super(x, y) ;
    }
                                                          this.c = c ;
                                                       }                        super fait appel au
                                                     }                          constructeur Point




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 :




                                                                                                       18
Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java



    public class ClasseA {
      int x ;
    }


                         public class ClasseB extends ClasseA {
                                                                           L’attribut x de la class B hérité de A
                           double x ;
                         }                                                 est devenu de type double.




           L’attribut x de la class C hérité de B                 public class ClasseC extends ClasseB {
           est devenu de type réel.                                 float x ;
                                                                  }




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 :



                                    public final void A( ) {

                                    }



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 :


                                    public final class B {

                                    }


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.



                                                                                                             19
Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java


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 ( ) ;
                                                                             Résultat de la méthode main :
                              aobjet.message();                              Bonjour
                              bobjet.message();                              Mr
                              cobjet.message();                              BOUHOUCHI

                          }
              }




                                                                                                   20
Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java




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.




                                                                                                21
Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java


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 :

                           public abstract nomDelaClasse( ){
                                  //il n’y a aucun codes dans la
                                  méthode abstraite
                           }



      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 class A {
                        private int i=5 ;
                        public abstract void Afficher(int somme ) ;
                        public void Calculer ( ) {
                        int somme ;
                        somme = i+5 ;
                        afficher( int somme ) ;
                        }
                 }




                                                                                             22
Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java


    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 :

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




    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 :


     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                     public class Calcul2 extends Analyse
{double multiplication(double x,double y){               {
              return x * y;                              double multiplication(double x,double
            }                                            y){
  double addition(double x,double y){                                  return x/2 * y/2;
              return x + y;                                          }
            }                                              double addition(double x,double y){
}                                                                      return x/2 + y/2;
                                                                     }
                                                         }


                                                                                                    23
    Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java


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


         }



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


         }




                                                                                             24
Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java


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




                         Résultat de l’exécution avec sortie du programme




  Exception in thread "main" Java.lang.ArithmeticException: / by zero

            at tests.TestException.main(TestException.Java:23)




                                                                                             25
Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java


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
                                                                                   Error
       Exception




RunTimeException                              Autres



                                                                                                 26
Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java


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 :


                          try
                            {
                                ...
                             }
                          catch (<une-exception>)
                             {
                               ...
                             }
                          catch (<une_autre_exception>)
                             {
                               ...
                             }
                          ...
                          finally
                             {
                               ...
                             }



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.

                                                                                                  27
Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java


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 :

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

      }



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.


              private void analyseTerme() throws SyntaxException
              {
                        if (texte.PremierCar() == '(')
                      { texte.caractereSuivant();
                        analyseSomme();
                        if (texte.PremierCar() != ')')
                           throw new SyntaxException();
                        texte.caractereSuivant();
                      }
                    else
                      { analyseChiffre();
                        return;
                      }
               }


                                                                                                 28
Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java


Pour lever l’exception, voici un autre exemple(*) :


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




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.




                                                                                                     29
Riadh BOUHOUCHI
Chapitre5 : Les Objets dans Java


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




                                                                                 30
Riadh BOUHOUCHI

Contenu connexe

En vedette

Présentation défi entreprises_2012
Présentation défi entreprises_2012Présentation défi entreprises_2012
Présentation défi entreprises_2012Danielriou
 
Firmenpräsi(kurz) clavis IT 2011
Firmenpräsi(kurz) clavis IT 2011Firmenpräsi(kurz) clavis IT 2011
Firmenpräsi(kurz) clavis IT 2011Martin Frischknecht
 
Les personnes handicapées et l'emploi : le bilan 2010 de l'Agefiph
Les personnes handicapées et l'emploi  : le bilan 2010 de l'AgefiphLes personnes handicapées et l'emploi  : le bilan 2010 de l'Agefiph
Les personnes handicapées et l'emploi : le bilan 2010 de l'AgefiphChristophe Lemesre
 
Feste 2, Yom Kippur
Feste 2, Yom KippurFeste 2, Yom Kippur
Feste 2, Yom Kippurwusternberg
 
Elise Beauregard Liste de Prix
Elise Beauregard Liste de PrixElise Beauregard Liste de Prix
Elise Beauregard Liste de Prixmustic
 
Altime Associates Newsletter Finances Janvier 2013
Altime Associates Newsletter Finances Janvier 2013Altime Associates Newsletter Finances Janvier 2013
Altime Associates Newsletter Finances Janvier 2013Altime Associates
 
Resolution sur les raids israélien contre chaine de tv palestinienne
Resolution sur les raids israélien contre chaine de tv palestinienneResolution sur les raids israélien contre chaine de tv palestinienne
Resolution sur les raids israélien contre chaine de tv palestinienneplumandon
 
Résultats etude france_g_2011
Résultats etude france_g_2011Résultats etude france_g_2011
Résultats etude france_g_2011Agence Excel
 
Présentation défi entreprises_2012_employé
Présentation défi entreprises_2012_employéPrésentation défi entreprises_2012_employé
Présentation défi entreprises_2012_employéDanielriou
 
Tome 3 : Gestion interne de la collectivite
Tome 3 : Gestion interne de la collectiviteTome 3 : Gestion interne de la collectivite
Tome 3 : Gestion interne de la collectiviteparoles d'élus
 
Trojanisches marketing mc siegen - 2011-05-03 - endversion - komprimiert
 Trojanisches marketing   mc siegen - 2011-05-03 - endversion - komprimiert Trojanisches marketing   mc siegen - 2011-05-03 - endversion - komprimiert
Trojanisches marketing mc siegen - 2011-05-03 - endversion - komprimiertWolfgang A. Engel
 
Geld ist für die Menschen da - Markenführung in einer Social Bank
Geld ist für die Menschen da - Markenführung in einer Social BankGeld ist für die Menschen da - Markenführung in einer Social Bank
Geld ist für die Menschen da - Markenführung in einer Social BankJohannes Korten
 
Wieviel Gebet ErhöRt Gott (Format Powerpoint 2007)
Wieviel Gebet ErhöRt Gott (Format Powerpoint 2007)Wieviel Gebet ErhöRt Gott (Format Powerpoint 2007)
Wieviel Gebet ErhöRt Gott (Format Powerpoint 2007)wusternberg
 

En vedette (18)

Présentation défi entreprises_2012
Présentation défi entreprises_2012Présentation défi entreprises_2012
Présentation défi entreprises_2012
 
Bismut2
Bismut2Bismut2
Bismut2
 
Firmenpräsi(kurz) clavis IT 2011
Firmenpräsi(kurz) clavis IT 2011Firmenpräsi(kurz) clavis IT 2011
Firmenpräsi(kurz) clavis IT 2011
 
Les personnes handicapées et l'emploi : le bilan 2010 de l'Agefiph
Les personnes handicapées et l'emploi  : le bilan 2010 de l'AgefiphLes personnes handicapées et l'emploi  : le bilan 2010 de l'Agefiph
Les personnes handicapées et l'emploi : le bilan 2010 de l'Agefiph
 
Feste 2, Yom Kippur
Feste 2, Yom KippurFeste 2, Yom Kippur
Feste 2, Yom Kippur
 
Elise Beauregard Liste de Prix
Elise Beauregard Liste de PrixElise Beauregard Liste de Prix
Elise Beauregard Liste de Prix
 
Altime Associates Newsletter Finances Janvier 2013
Altime Associates Newsletter Finances Janvier 2013Altime Associates Newsletter Finances Janvier 2013
Altime Associates Newsletter Finances Janvier 2013
 
Resolution sur les raids israélien contre chaine de tv palestinienne
Resolution sur les raids israélien contre chaine de tv palestinienneResolution sur les raids israélien contre chaine de tv palestinienne
Resolution sur les raids israélien contre chaine de tv palestinienne
 
Finanzskandal in Brandenburg
Finanzskandal in BrandenburgFinanzskandal in Brandenburg
Finanzskandal in Brandenburg
 
La statue
La statueLa statue
La statue
 
Résultats etude france_g_2011
Résultats etude france_g_2011Résultats etude france_g_2011
Résultats etude france_g_2011
 
Présentation défi entreprises_2012_employé
Présentation défi entreprises_2012_employéPrésentation défi entreprises_2012_employé
Présentation défi entreprises_2012_employé
 
Tome 3 : Gestion interne de la collectivite
Tome 3 : Gestion interne de la collectiviteTome 3 : Gestion interne de la collectivite
Tome 3 : Gestion interne de la collectivite
 
Trojanisches marketing mc siegen - 2011-05-03 - endversion - komprimiert
 Trojanisches marketing   mc siegen - 2011-05-03 - endversion - komprimiert Trojanisches marketing   mc siegen - 2011-05-03 - endversion - komprimiert
Trojanisches marketing mc siegen - 2011-05-03 - endversion - komprimiert
 
Geld ist für die Menschen da - Markenführung in einer Social Bank
Geld ist für die Menschen da - Markenführung in einer Social BankGeld ist für die Menschen da - Markenführung in einer Social Bank
Geld ist für die Menschen da - Markenführung in einer Social Bank
 
Le présent
Le présentLe présent
Le présent
 
ssp800hd fiche produit
ssp800hd fiche produitssp800hd fiche produit
ssp800hd fiche produit
 
Wieviel Gebet ErhöRt Gott (Format Powerpoint 2007)
Wieviel Gebet ErhöRt Gott (Format Powerpoint 2007)Wieviel Gebet ErhöRt Gott (Format Powerpoint 2007)
Wieviel Gebet ErhöRt Gott (Format Powerpoint 2007)
 

Similaire à JAVA Chapitre5

Similaire à JAVA Chapitre5 (20)

Framework Orienté objet
Framework Orienté objetFramework Orienté objet
Framework Orienté objet
 
Support du cours : Programmation Web 2
Support du cours : Programmation Web 2Support du cours : Programmation Web 2
Support du cours : Programmation Web 2
 
Generateur de code java (GenJAVA)
Generateur de code java (GenJAVA)Generateur de code java (GenJAVA)
Generateur de code java (GenJAVA)
 
Livret java
Livret javaLivret java
Livret java
 
Java
JavaJava
Java
 
programmation orienté objet c++
programmation orienté objet c++programmation orienté objet c++
programmation orienté objet c++
 
Cours java smi_2011_2012_partie_i_29_octobre_2011
Cours java smi_2011_2012_partie_i_29_octobre_2011Cours java smi_2011_2012_partie_i_29_octobre_2011
Cours java smi_2011_2012_partie_i_29_octobre_2011
 
UML Part 4- diagrammres de classes et d'objets mansouri
UML Part 4- diagrammres de classes et d'objets mansouriUML Part 4- diagrammres de classes et d'objets mansouri
UML Part 4- diagrammres de classes et d'objets mansouri
 
POO
POOPOO
POO
 
Langage C#
Langage C#Langage C#
Langage C#
 
4711538.pptx
4711538.pptx4711538.pptx
4711538.pptx
 
Design patterns
Design patternsDesign patterns
Design patterns
 
Chap7 developpement modele statique
Chap7 developpement modele statiqueChap7 developpement modele statique
Chap7 developpement modele statique
 
Architecture Logiciel_GRASP11111111.pptx
Architecture Logiciel_GRASP11111111.pptxArchitecture Logiciel_GRASP11111111.pptx
Architecture Logiciel_GRASP11111111.pptx
 
Poly basesjavahm
Poly basesjavahmPoly basesjavahm
Poly basesjavahm
 
Le framework-executor
Le framework-executorLe framework-executor
Le framework-executor
 
Excel2010.guide.complet
Excel2010.guide.completExcel2010.guide.complet
Excel2010.guide.complet
 
Excel 2010 - Fonctions et formules
Excel 2010 - Fonctions et formulesExcel 2010 - Fonctions et formules
Excel 2010 - Fonctions et formules
 
47750479 cours-c
47750479 cours-c47750479 cours-c
47750479 cours-c
 
73720847 6838-491f-b7df-ac3f144d019f
73720847 6838-491f-b7df-ac3f144d019f73720847 6838-491f-b7df-ac3f144d019f
73720847 6838-491f-b7df-ac3f144d019f
 

Plus de Mohamed Ferchichi (13)

JAVA Chapitre8
JAVA Chapitre8JAVA Chapitre8
JAVA Chapitre8
 
JAVA Chapitre7
JAVA Chapitre7JAVA Chapitre7
JAVA Chapitre7
 
JAVA Chapitre6
JAVA Chapitre6JAVA Chapitre6
JAVA Chapitre6
 
JAVA Chapitre4
JAVA Chapitre4JAVA Chapitre4
JAVA Chapitre4
 
JAVA Chapitre3
JAVA Chapitre3JAVA Chapitre3
JAVA Chapitre3
 
JAVA Chapitre2
JAVA Chapitre2JAVA Chapitre2
JAVA Chapitre2
 
JAVA Chapitre1
JAVA Chapitre1 JAVA Chapitre1
JAVA Chapitre1
 
Résumé sur l’utilisation du système unix
Résumé sur l’utilisation du système unixRésumé sur l’utilisation du système unix
Résumé sur l’utilisation du système unix
 
Parti 2 utilitaires pour fichiers
Parti 2 utilitaires pour fichiersParti 2 utilitaires pour fichiers
Parti 2 utilitaires pour fichiers
 
Parti 1 concepts de base
Parti 1 concepts de baseParti 1 concepts de base
Parti 1 concepts de base
 
Trame mic
Trame micTrame mic
Trame mic
 
Cours gestion et economie 1
Cours gestion et economie 1Cours gestion et economie 1
Cours gestion et economie 1
 
Traitement de signal 1
Traitement de signal 1Traitement de signal 1
Traitement de signal 1
 

Dernier

Présentation - Initiatives - CECOSDA - OIF - Fact Checking.pptx
Présentation - Initiatives - CECOSDA - OIF - Fact Checking.pptxPrésentation - Initiatives - CECOSDA - OIF - Fact Checking.pptx
Présentation - Initiatives - CECOSDA - OIF - Fact Checking.pptxJCAC
 
Vulnérabilité numérique d’usage : un enjeu pour l’aide à la réussitepdf
Vulnérabilité numérique d’usage : un enjeu pour l’aide à la réussitepdfVulnérabilité numérique d’usage : un enjeu pour l’aide à la réussitepdf
Vulnérabilité numérique d’usage : un enjeu pour l’aide à la réussitepdfSylvianeBachy
 
Apprendre avec des top et nano influenceurs
Apprendre avec des top et nano influenceursApprendre avec des top et nano influenceurs
Apprendre avec des top et nano influenceursStagiaireLearningmat
 
Bibdoc 2024 - L’Éducation aux Médias et à l’Information face à l’intelligence...
Bibdoc 2024 - L’Éducation aux Médias et à l’Information face à l’intelligence...Bibdoc 2024 - L’Éducation aux Médias et à l’Information face à l’intelligence...
Bibdoc 2024 - L’Éducation aux Médias et à l’Information face à l’intelligence...Bibdoc 37
 
Chana Orloff.pptx Sculptrice franco-ukranienne
Chana Orloff.pptx Sculptrice franco-ukranienneChana Orloff.pptx Sculptrice franco-ukranienne
Chana Orloff.pptx Sculptrice franco-ukranienneTxaruka
 
Pas de vagues. pptx Film français
Pas de vagues.  pptx   Film     françaisPas de vagues.  pptx   Film     français
Pas de vagues. pptx Film françaisTxaruka
 
Calendrier de la semaine du 8 au 12 avril
Calendrier de la semaine du 8 au 12 avrilCalendrier de la semaine du 8 au 12 avril
Calendrier de la semaine du 8 au 12 avrilfrizzole
 
Aux origines de la sociologie : du XIXème au début XX ème siècle
Aux origines de la sociologie : du XIXème au début XX ème siècleAux origines de la sociologie : du XIXème au début XX ème siècle
Aux origines de la sociologie : du XIXème au début XX ème siècleAmar LAKEL, PhD
 
Bibdoc 2024 - Sobriete numerique en bibliotheque et centre de documentation.pdf
Bibdoc 2024 - Sobriete numerique en bibliotheque et centre de documentation.pdfBibdoc 2024 - Sobriete numerique en bibliotheque et centre de documentation.pdf
Bibdoc 2024 - Sobriete numerique en bibliotheque et centre de documentation.pdfBibdoc 37
 
DIGNITAS INFINITA - DIGNITÉ HUMAINE; déclaration du dicastère .pptx
DIGNITAS INFINITA - DIGNITÉ HUMAINE; déclaration du dicastère .pptxDIGNITAS INFINITA - DIGNITÉ HUMAINE; déclaration du dicastère .pptx
DIGNITAS INFINITA - DIGNITÉ HUMAINE; déclaration du dicastère .pptxMartin M Flynn
 
Bibdoc 2024 - Les intelligences artificielles en bibliotheque.pdf
Bibdoc 2024 - Les intelligences artificielles en bibliotheque.pdfBibdoc 2024 - Les intelligences artificielles en bibliotheque.pdf
Bibdoc 2024 - Les intelligences artificielles en bibliotheque.pdfBibdoc 37
 
Pas de vagues. pptx Film français
Pas de vagues.  pptx      Film   françaisPas de vagues.  pptx      Film   français
Pas de vagues. pptx Film françaisTxaruka
 
Faut-il avoir peur de la technique ? (G. Gay-Para)
Faut-il avoir peur de la technique ? (G. Gay-Para)Faut-il avoir peur de la technique ? (G. Gay-Para)
Faut-il avoir peur de la technique ? (G. Gay-Para)Gabriel Gay-Para
 
Newsletter SPW Agriculture en province du Luxembourg du 10-04-24
Newsletter SPW Agriculture en province du Luxembourg du 10-04-24Newsletter SPW Agriculture en province du Luxembourg du 10-04-24
Newsletter SPW Agriculture en province du Luxembourg du 10-04-24BenotGeorges3
 
La Base unique départementale - Quel bilan, au bout de 5 ans .pdf
La Base unique départementale - Quel bilan, au bout de 5 ans .pdfLa Base unique départementale - Quel bilan, au bout de 5 ans .pdf
La Base unique départementale - Quel bilan, au bout de 5 ans .pdfbdp12
 

Dernier (16)

Présentation - Initiatives - CECOSDA - OIF - Fact Checking.pptx
Présentation - Initiatives - CECOSDA - OIF - Fact Checking.pptxPrésentation - Initiatives - CECOSDA - OIF - Fact Checking.pptx
Présentation - Initiatives - CECOSDA - OIF - Fact Checking.pptx
 
Vulnérabilité numérique d’usage : un enjeu pour l’aide à la réussitepdf
Vulnérabilité numérique d’usage : un enjeu pour l’aide à la réussitepdfVulnérabilité numérique d’usage : un enjeu pour l’aide à la réussitepdf
Vulnérabilité numérique d’usage : un enjeu pour l’aide à la réussitepdf
 
Apprendre avec des top et nano influenceurs
Apprendre avec des top et nano influenceursApprendre avec des top et nano influenceurs
Apprendre avec des top et nano influenceurs
 
Bibdoc 2024 - L’Éducation aux Médias et à l’Information face à l’intelligence...
Bibdoc 2024 - L’Éducation aux Médias et à l’Information face à l’intelligence...Bibdoc 2024 - L’Éducation aux Médias et à l’Information face à l’intelligence...
Bibdoc 2024 - L’Éducation aux Médias et à l’Information face à l’intelligence...
 
Bulletin des bibliotheques Burkina Faso mars 2024
Bulletin des bibliotheques Burkina Faso mars 2024Bulletin des bibliotheques Burkina Faso mars 2024
Bulletin des bibliotheques Burkina Faso mars 2024
 
Chana Orloff.pptx Sculptrice franco-ukranienne
Chana Orloff.pptx Sculptrice franco-ukranienneChana Orloff.pptx Sculptrice franco-ukranienne
Chana Orloff.pptx Sculptrice franco-ukranienne
 
Pas de vagues. pptx Film français
Pas de vagues.  pptx   Film     françaisPas de vagues.  pptx   Film     français
Pas de vagues. pptx Film français
 
Calendrier de la semaine du 8 au 12 avril
Calendrier de la semaine du 8 au 12 avrilCalendrier de la semaine du 8 au 12 avril
Calendrier de la semaine du 8 au 12 avril
 
Aux origines de la sociologie : du XIXème au début XX ème siècle
Aux origines de la sociologie : du XIXème au début XX ème siècleAux origines de la sociologie : du XIXème au début XX ème siècle
Aux origines de la sociologie : du XIXème au début XX ème siècle
 
Bibdoc 2024 - Sobriete numerique en bibliotheque et centre de documentation.pdf
Bibdoc 2024 - Sobriete numerique en bibliotheque et centre de documentation.pdfBibdoc 2024 - Sobriete numerique en bibliotheque et centre de documentation.pdf
Bibdoc 2024 - Sobriete numerique en bibliotheque et centre de documentation.pdf
 
DIGNITAS INFINITA - DIGNITÉ HUMAINE; déclaration du dicastère .pptx
DIGNITAS INFINITA - DIGNITÉ HUMAINE; déclaration du dicastère .pptxDIGNITAS INFINITA - DIGNITÉ HUMAINE; déclaration du dicastère .pptx
DIGNITAS INFINITA - DIGNITÉ HUMAINE; déclaration du dicastère .pptx
 
Bibdoc 2024 - Les intelligences artificielles en bibliotheque.pdf
Bibdoc 2024 - Les intelligences artificielles en bibliotheque.pdfBibdoc 2024 - Les intelligences artificielles en bibliotheque.pdf
Bibdoc 2024 - Les intelligences artificielles en bibliotheque.pdf
 
Pas de vagues. pptx Film français
Pas de vagues.  pptx      Film   françaisPas de vagues.  pptx      Film   français
Pas de vagues. pptx Film français
 
Faut-il avoir peur de la technique ? (G. Gay-Para)
Faut-il avoir peur de la technique ? (G. Gay-Para)Faut-il avoir peur de la technique ? (G. Gay-Para)
Faut-il avoir peur de la technique ? (G. Gay-Para)
 
Newsletter SPW Agriculture en province du Luxembourg du 10-04-24
Newsletter SPW Agriculture en province du Luxembourg du 10-04-24Newsletter SPW Agriculture en province du Luxembourg du 10-04-24
Newsletter SPW Agriculture en province du Luxembourg du 10-04-24
 
La Base unique départementale - Quel bilan, au bout de 5 ans .pdf
La Base unique départementale - Quel bilan, au bout de 5 ans .pdfLa Base unique départementale - Quel bilan, au bout de 5 ans .pdf
La Base unique départementale - Quel bilan, au bout de 5 ans .pdf
 

JAVA Chapitre5

  • 1. Chapitre5 : Les Objets dans Java 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. 1 Riadh BOUHOUCHI
  • 2. Chapitre5 : Les Objets dans Java 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 2 Riadh BOUHOUCHI
  • 3. Chapitre5 : Les Objets dans Java La déclaration des exceptions (throws), cas des RuntimeException .................................................... 28 Cas des RuntimeException ................................................................................................................ 29 Développer des classes d'exception personnalisées............................................................................. 29 3 Riadh BOUHOUCHI
  • 4. Chapitre5 : Les Objets dans Java 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). 4 Riadh BOUHOUCHI
  • 5. Chapitre5 : Les Objets dans Java 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 : class Voiture Attributs Méthodes Marque Démarrer Modèle Accélérer Immatriculation Freiner Vitesse Stopper Niveaudecarburant Vidanger Puissancefiscale Etc .... PuissanceDIN Etc ... Voici un exemple d’instances de la classe voiture : PEUGEOT RENAULT 54S ULTIMA V6 3412 SM 59 4954 VD 59 130 Km /h 190 Km /h 54 l 62 l 15 CV 23 CV 120 DIN, ... 160 DIN, ... Nom de l’objet Voiture _Peugeot Peugeot :Marque 5 Riadh BOUHOUCHI
  • 6. Chapitre5 : Les Objets dans Java 54S :Modèle 3412 SM 59 :Immatriculation 130 Km /h :Vitesse Les attributs 54 l :Niveaudecarburant 15 CV :Puissancefiscale 120 DIN :PuissanceDIN Démarrer ( ) Accélérer ( ) Freiner ( ) Les méthodes 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 : 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( ) ; } } 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. 6 Riadh BOUHOUCHI
  • 7. Chapitre5 : Les Objets dans Java  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é 7 Riadh BOUHOUCHI
  • 8. Chapitre5 : Les Objets dans Java 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 8 Riadh BOUHOUCHI
  • 9. Chapitre5 : Les Objets dans Java  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){ Déclaration des variables et appel de class extérieure Déclaration de la méthode type1 ; type2 ; Class1 c= new Class1 ( ); ... type N; instruction 1; instruction 1; resultat=c.methodeB(); ... Appel d’une méthode instruction N; return; externe de notre class Déclaration d’instructions } 9 Riadh BOUHOUCHI
  • 10. Chapitre5 : Les Objets dans Java 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 : 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; } } } 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. 10 Riadh BOUHOUCHI
  • 11. Chapitre5 : Les Objets dans Java 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 : public class Test { private int i; private boolean condition; public Test() { i = 0; condition = false; System.out.println("La construction est realiser"); } } 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. 11 Riadh BOUHOUCHI
  • 12. Chapitre5 : Les Objets dans Java Exemple de destruction : public void finalize() { System.out.println("mémoire nettoyer"); } 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 : int[] tab ; tab = new int[20]; Déclarer le type du tableau OU Fixer la taille du tableau int[] tab = new int[20]; Déclarer le type des variables Exemple d’utilisation d’un tableau : Class Tableau { String [] tab=new String [2] ; public static void main(String[] args) { tab*1+ = ”a”; System.out.println( tab[1] ); } } 12 Riadh BOUHOUCHI
  • 13. Chapitre5 : Les Objets dans Java 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 : 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; } 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. 13 Riadh BOUHOUCHI
  • 14. Chapitre5 : Les Objets dans Java 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. 14 Riadh BOUHOUCHI
  • 15. Chapitre5 : Les Objets dans Java 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 : Class A la classe mère public class A { extends permet a un classe fille public void Bonjour ( ) { System.out.println(« Bonjour ») ; d’hériter les caractéristiques de la } classe mère. } C cobjet = new C () ; cobjet.Bye () ; => Bye public class B extends A { cobjet.Salut () ; => Salut cobjet.Bonjour () ; => Bonjour public void Salut ( ) { System.out.println(« Salut »); } } B bobjet = new B() ; Class B et C les classes filles bobjet.Bye () ; => Bye La class B n’hérite pas de la public class C extends B { class C Public void Bye ( ) { System.out.println(«Bye ») ; bobjet.Salut () ; => Salut } bobjet.Bonjour () ; => Bonjour } 15 Riadh BOUHOUCHI
  • 16. Chapitre5 : Les Objets dans Java 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 ». 16 Riadh BOUHOUCHI
  • 17. Chapitre5 : Les Objets dans Java class A { String chaine = “Bonjour”; Résultat : void A (new chaine){  Bonjour Mr System.out.print ( chaine); System.out.println ( new chaine); } }  Au revoir Ami class B { A abojet = new A( ); aobjet.A(“Mr”); aobjet.chaine(“ Au revoir ”); aobjet.A(“ Ami ”); } 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 ( ) ; 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. 17 Riadh BOUHOUCHI
  • 18. Chapitre5 : Les Objets dans Java public class B extends A { String sportPratiqué ; Le résultat de la class B par la Public void affiche () { super.affiche() ; méthode affiche ( ) appelée System.out.println(“BOUHOUCHI ” ); par super de la class A: } } Bonjour Mr. BOUHOUCHI 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 : public class Point { double x, y ; public Point (double x, double y) { public class PointCouleur extends Point { this.x = x ; Color c; this.y = y ; public PointCouleur (double x, double y, Color c) { } super(x, y) ; } this.c = c ; } super fait appel au } constructeur Point 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 : 18 Riadh BOUHOUCHI
  • 19. Chapitre5 : Les Objets dans Java public class ClasseA { int x ; } public class ClasseB extends ClasseA { L’attribut x de la class B hérité de A double x ; } est devenu de type double. L’attribut x de la class C hérité de B public class ClasseC extends ClasseB { est devenu de type réel. float x ; } 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 : public final void A( ) { } 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 : public final class B { } 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. 19 Riadh BOUHOUCHI
  • 20. Chapitre5 : Les Objets dans Java 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 ( ) ; Résultat de la méthode main : aobjet.message(); Bonjour bobjet.message(); Mr cobjet.message(); BOUHOUCHI } } 20 Riadh BOUHOUCHI
  • 21. Chapitre5 : Les Objets dans Java 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. 21 Riadh BOUHOUCHI
  • 22. Chapitre5 : Les Objets dans Java 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 : public abstract nomDelaClasse( ){ //il n’y a aucun codes dans la méthode abstraite }  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 class A { private int i=5 ; public abstract void Afficher(int somme ) ; public void Calculer ( ) { int somme ; somme = i+5 ; afficher( int somme ) ; } } 22 Riadh BOUHOUCHI
  • 23. Chapitre5 : Les Objets dans Java 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 : 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 ) ; } } 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 : 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 public class Calcul2 extends Analyse {double multiplication(double x,double y){ { return x * y; double multiplication(double x,double } y){ double addition(double x,double y){ return x/2 * y/2; return x + y; } } double addition(double x,double y){ } return x/2 + y/2; } } 23 Riadh BOUHOUCHI
  • 24. Chapitre5 : Les Objets dans Java 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 : 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) ; } 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 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;} } 24 Riadh BOUHOUCHI
  • 25. Chapitre5 : Les Objets dans Java 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)); } } Résultat de l’exécution avec sortie du programme Exception in thread "main" Java.lang.ArithmeticException: / by zero at tests.TestException.main(TestException.Java:23) 25 Riadh BOUHOUCHI
  • 26. Chapitre5 : Les Objets dans Java 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 Error Exception RunTimeException Autres 26 Riadh BOUHOUCHI
  • 27. Chapitre5 : Les Objets dans Java 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 : try { ... } catch (<une-exception>) { ... } catch (<une_autre_exception>) { ... } ... finally { ... } 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. 27 Riadh BOUHOUCHI
  • 28. Chapitre5 : Les Objets dans Java 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 : 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“ ); } } } 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. private void analyseTerme() throws SyntaxException { if (texte.PremierCar() == '(') { texte.caractereSuivant(); analyseSomme(); if (texte.PremierCar() != ')') throw new SyntaxException(); texte.caractereSuivant(); } else { analyseChiffre(); return; } } 28 Riadh BOUHOUCHI
  • 29. Chapitre5 : Les Objets dans Java Pour lever l’exception, voici un autre exemple(*) : 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; } } 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. 29 Riadh BOUHOUCHI
  • 30. Chapitre5 : Les Objets dans Java 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); }; } } 30 Riadh BOUHOUCHI