DOC

Java Les concepts de programmation

By Alice Sanders,2014-04-24 14:31
7 views 0
Java Les concepts de programmation

    TD3 : Java : Les Objets dans leurs classes

    1. Principe d’héritage Objectif : Réutiliser des classes déjà écrites afin d’ajouter ou de retirer certaines de

    ses fonctionnalités.

Il est possible de redéfinir un type à partir d’un autre type.

    Par exemple :

    public class Chat{

     protected int age ;

     protected int nbPattes ;

     Chat( ){ //Constructeur standard

     this(1,4) ;

     }

     Chat(int lAge, int leNombreDePattes){

     this.age=lAge ;

     this.nbPattes=leNombreDePattes ;

     }

     public int getAge(){ return this.age ;}

     public int getNbPattes(){return this.nbPattes ;}

    }

    Définit une classe chat qui contient l’age et le nombre de pattes du chat. Si je veux

    définir une classe ChatAPoils qui identifie la couleur de son pelage, je peux soit

    redéfinir entièrement la classe, soit hériter de la classe Chat et y ajouter la propriété

    (et l’accesseur associé) couleur.

public class ChatAPoils extends Chat {

     protected String couleur ;

     ChatAPoils( ){

     super() ;

     this.couleur= ? noir ?;

     }

     ChatAPoils (int lAge, int leNombreDePatte, String laCouleur){

     super(lAge, leNombreDePatte) ;

     this.couleur=laCouleur ;

     }

     public String getCouleur(){ return this.couleur ;}

Il existe donc une relation d’héritage entre les classes.

    Chat

    ChatAPoils

    Java Fabrice Jaillet / Stéphane Frénot IUT Bourg en bresse - 1999 1/5

    Une instance de ChatAPoils est à la fois une instance de ChatAPoils, mais

    également de Chat, ainsi tous les messages destinés à un objet ChatAPoils, unChatAPoilsdéclarés dans la classe Chat sont compris par ce ChatAPoils, puisqu'il est également

    . couleur=vertun Chat.

    Chat

    . age=35

    . nbPattes=4

    getCouleur()

    getNbPattes()

    getAge()

    Exercice n?1 :

    faire une classe ChatATroisPattes()

    représenter les relations d’héritage entre les trois classes.

2. Les classes/méthodes abstraites

    On a le droit de définir des classes donc certaines méthodes sont déclarées, mais

    dont l’implantation n’est pas (encore) réalisée. On les appelle des méthodes

    abstraites.

    Une classe possédant au moins une méthode abstraite s’appelle une classe abstraite.

    On ne peut pas instancier un objet à partir d’une classe abstraite, il ne saurait pas quoi faire à réception d'un message sur une méthode abstraite.

    Il faut définir une classe concrète qui hérite de la classe abstraite et donne

    l'implantation des méthodes abstraites héritées. L’objet instancié à partir de la classe concrète répond donc à la fois aux méthodes concrètes définie dans la classe

    abstraite et à la fois au méthode concrètes définie dans la sous-classe.

Une classe abstraite est un pré-moule de définition d’autres classes.

    Le mot clé abstract permet de spécifier qu’une méthode (ou une classe) est abstraite :

     public abstract Animal{

     protected int age ;

     public int getAge(){return this.age ;}

     public abstract int getNbPattes() ;

     }

Exercice n?2 :

    Java Fabrice Jaillet / Stéphane Frénot IUT Bourg en bresse - 1999 2/5

    1) Définir la classe de définition d’un carré.

    2) Définir les attributs qui permettent de donner son centre (x, y)

    3) Définir la méthode qui permet de renvoyer sa surface

    4) Définir une classe cercle avec son centre

    5) Définir la méthode qui permet de renvoyer sa surface

    6) Définir une classe forme géométrique qui possède une méthode qui renvoie sa

    surface

    Les classes abstraites fabriquent des objets génériques n’implantant que des

    mécanismes de base. La définition de classes abstraites se fait souvent en

    regroupant les déclarations communes à plusieurs classes concrètes dans une seule

    classe. Par exemple la classe Component sous Java est une classe abstraite qui

    représente un objet graphique quelconque. Les différents composants graphiques

    concrets (boutons, zone de liste…) héritent directement de cette classe.

     ComponentExercice n?3 :

    Commenter la relation d’héritage suivante :

    Bouton

    TextComponent

    TextField

    TextArea

3. Les interfaces

    Techniquement une interface est une classe entièrement abstraite, c’est-à-dire

    qu’elle ne contient que des méthodes abstraites, et dont tous les membres sont

    public static final.

La notion d’interface permet d’implanter un mécanisme de comportement d’objet. Il

    s’agit d’un contrat que l’objet accepte de réaliser. L’interface définit les méthodes que

    la classe doit implanter afin de répondre au contrat.

    On dit qu'une classe implante une interface, lorsqu'elle fournit le code nécessaire à la

    réalisation du contrat.

    Par exemple un comportement sur une personne peut être le fait qu’elle soit

    joignable (une interface représente une faculté de réaliser quelque chose. son nom

    se termine souvent par -able). Ainsi on peut définir une interface Joignable ainsi.

public interface Joignable {

     public String getEMail() ;

     public String getPhone() ;

    }

Java Fabrice Jaillet / Stéphane Frénot IUT Bourg en bresse - 1999

    3/5

    Ainsi les classes qui implanterons cette interface devront implanter concrètement ces

    méthodes.

    class Etudiant implements Joignable{

     protected String nom ;

     protected String mail ;

     protected String phone ;

     Etudiant(String leNom, String leMail){

     this.nom=leNom ;

     this.mail=leMail ;

     }

    //Méthodes imposées par l’interface

     public String getEMail(){

     return this.mail ;

     }

     public String getPhone(){

     return this.phone ;

     }

    }

    Une classe peut demander à implanter autant d’interfaces qu’elle veut. Elle doit alors

    implanter toutes les méthodes permettant de répondre aux contrats définis par toutes

    les interfaces.

    class Cercle extends FigureGeometrique implements translatable, supprimable,

    affichable, dessinable {

    

    }

    Une classe définit donc ce qu’est un objet par ses relations d’héritage et ce qu’il

    accepte de réaliser par ses relations d’implantation.

    Exercice n?4 :

    Définir la hiérarchie d’héritage et d’implantation reliant les supports de stockage

    d’information (disque, disquette, cdrom), en distinguant les fonctions de lecture et

    d’écriture.

4. L’opérateur de cast

    Grâce aux deux mécanismes précédents un objet peut être vu de différentes

    manières. On peut forcer la manière de voir un objet en le castant selon la classe

    désirée (caster = forcer un objet à paraître instance d'une autre classe).

ChatATroisPattes unChatATroisPattes=new ChatATroisPattes() ;

    Chat unChat=unChatATroisPattes ; //

    //unChatATroisPattes=unChat ; //erreur à la compilation

    unChatATroisPattes=(Chat)unChat ;

Java Fabrice Jaillet / Stéphane Frénot IUT Bourg en bresse - 1999

    4/5

lesChats = new Vector() ;

    lesChats.addElement(new Chat()) ;

    lesChats.addElement(new Chat(? michele ?, 23)) ;

    lesChats.addElement(new ChatAPoils(? philippe ?,15)) ;

Chat unChat=(Chat)lesChats.elementAt(0) ;

    ChatAPoils unChatAPoil=(ChatAPoils)lesChats.elementAt(2) ;

Remarque : comment se rappeler du fonctionnement d’un cast.

    L’idée est qu’on ne peut pas tricher sur la classe d’un objet. On peut toujours

    transformer un objet vers une classe plus générale. (ChatATroisPattes -> Chat,

    String -> Object, ChatATroisPattes -> Object). Par contre lorsque l’on veut spécialiser

    l’objet il faut être sûr de la classe de l’objet.

    Chat unChat=new Chat() ;

    Object tmp=unChat ; // OK tmp est d’une classe plus générale que unChat

    Chat unNouveauChat=(Chat)tmp ; //OK on spécialise tmp, mais on est sûr du type

    //ChatAPoil unDernierChat=(ChatAPoils)tmp ; //KO perdu

Il est possible de tester la classe initiale d’un objet avec l’opérateur instanceof ou en

    "catchant" une exception de type ClassCastException :

Exercice n?5

    En reprenant le code d’initialisation précédent, je veux afficher la couleur de tous les

    chats à poils.

Réponses : A ne pas imprimer

    for (java.awt.Enumeration e=lesChats.elements() ; e.hasMoreElements ;{

     Object tmp=e.nextElement() ;

     if (tmp instanceof ChatAPoil){

     System.out.println(tmp.getCouleur()) ;

     }

    }

    La méthode que je préfère en utilisant le ClassCast

    for (java.awt.Enumeration e=lesChats.elements() ; e.hasMoreElements ;{

     try{

     ChatAPoil tmp=(ChatAPoil)e.nextElement() ;

     System.out.println(tmp.getCouleur()) ;

     } catch(ClassCastException e){ }

    } ? )

    (c’est quand même plus joli

    Java Fabrice Jaillet / Stéphane Frénot IUT Bourg en bresse - 1999

    5/5

Report this document

For any questions or suggestions please email
cust-service@docsford.com