LECON 205


Les interfaces
Voici donc l'un des autres fondements du langage : les interfaces !

Il ne s'agit pas ici d'interfaces graphiques...
Mais vous allez apercevoir ce que les programmeurs Java appellent le nec plus ultra du polymorphisme !
Je suis sûr que vous devez être impatients de voir ce point... Alors, qu'attendons nous ?

Sommaire du chapitre :
  • Une petite devinette
  • Votre première interface
  • Implémentation de l'interface Rintintin
  • Astuce d'Eclipse
  • Ce qu'il faut retenir

Une petite devinette

L'un des atouts majeurs, pour ne pas dire l'atout majeur, de la programmation orientée objet est la réutilisabilité de vos objets.
Il est bien commode de pouvoir utiliser un objet, voire même une architecture que nous avons développée dans une application nouvelle.

Admettons que l'architecture que nous avons développée dans les chapitres précédents forme une bonne base. Que se passerait-il si un autre développeur vous demande la possibilité d'utiliser vos objets dans un autre type d'application ?
Dans la nôtre, nous ne nous sommes occupés que de l'aspect générique des animaux que nous avons créés. Cependant, la personne qui vous a contacté, lui, développe une application pour un chenil.

La principale contrainte, c'est que vos chiens vont devoir apprendre à faire de nouvelles choses comme :
  • faire le beau,
  • faire des calins,
  • faire une léchouille.

Je ne vois pas le problème ! Tu n'as qu'à ajouter ces méthodes dans la classe Animal.

Oula ! Vous vous rendez bien compte que vous allez avoir des lions qui vont faire le beau ?
Dans ce cas, on n'a qu'à mettre ces méthodes dans la classe Chien !

Ceci pourrait être une solution, mais j'y vois deux contre-indications :
  • vous allez devoir mettre en oeuvre une convention de nommage entre vous et le programmeur qui va utiliser vos objets... Vous ne devrez pas utiliser une méthode faireCalin() alors que le programmeur utilise une méthode faireUnCalin() ;
  • si vous faites ceci. ADIEU LE POLYMORPHISME ! Vous ne pourrez pas appeler vos objets par le biais d'un super type. Pour pouvoir accéder à ces méthodes, vous devrez obligatoirement passer par une référence à un objet Chien. Pas terrible, tout ça...

Tu nous as dit que pour utiliser au mieux le polymorphisme, nous devions définir les méthodes au plus haut niveau de la hiérarchie.

Tout à fait.
Alors du coup, il faut redéfinir un super type pour pouvoir utiliser le polymorphisme !

Oui, et je vous rappelle que l'héritage multiple est interdit en Java. Et quand je dis interdit, je veux dire que Java ne gère pas ça !
Nous sommes sur la bonne voie. Il faudrait pouvoir développer un nouveau super type et s'en servir dans nos classes Chien.
Eh bien nous pouvons faire cela avec des interfaces.

En fait, les interfaces permettent de créer un nouveau super type ; on peut même en ajouter autant que nous le souhaitons dans une seule classe !
En plus, concernant l'utilisation de nos objets, la convention est toute trouvée... Pourquoi ? Parce qu'une interface n'est rien d'autre qu'une classe 100 % abstraite !
Allez : venons-en au fait !

Votre première interface

Pour définir une interface, au lieu d'écrire :
Code : Java -  
1
2
3
 
public class A{
 
}


il vous suffit de faire :
Code : Java -  
1
2
3
 
public interface I{
 
}


Voilà, vous venez d'apprendre à déclarer une interface. Maintenant, tant qu'à y ajouter des méthodes, vu qu'une interface est une classe 100 % abstraite, vous n'avez qu'à y mettre des méthodes abstraites. Mais sans mettre le mot clé abstract.
Voici des exemples d'interfaces :
Code : Java -  
1
2
3
4
5
6
 
public interface I{
 
   public void A();
   public String B();
 
}

Code : Java -  
1
2
3
4
5
6
 
public interface I2{
 
   public void C();
   public String D();
 
}


Et pour faire en sorte qu'une classe utilise une interface, il suffit d'utiliser le mot clé implements.
Ce qui nous donnerait :
Code : Java -  
1
2
3
4
5
6
7
8
9
 
public class X implements I{
    public void A(){
      //.......
    }
 
    public String B(){
      //.......
    }
}

Voilà, c'est tout. On dit que la classe X implémente l'interface I.
Et donc, comme je vous le disais, vous pouvez implémenter plusieurs interfaces, voilà donc comment ça se passe :
Code : Java -  
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
 
public class X implements I, I2{
   public void A(){
      //.......
    }
 
    public String B(){
      //.......
    }
 
    public void C(){
      //.......
    }
 
    public String D(){
      //.......
    }
}

Par contre, lorsque vous implémentez une ou plusieurs interfaces, vous DEVEZ OBLIGATOIREMENT redéfinir leurs méthodes !

Et ainsi, avec le polymorphisme, vous pouvez faire ceci :
Code : Java -  
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
 
public class Test{
 
   public static void main(String[] args){
      I var = new X();//Avec cette référence, vous pouvez utiliser de façon polymorphe les méthodes de l'interface I
      I2 var2 = new X();//Avec cette référence, vous pouvez utiliser de façon polymorphe les méthodes de l'interface I2
      var.A();
      var2.C();
   
   }
 
}


Maintenant que vous savez cela, attelons-nous à notre programme.

Implémentation de l'interface Rintintin

Voilà où nous en sommes


  • Nous voulons que nos chiens puissent être amicaux.
  • Nous voulons définir un super type pour pouvoir utiliser le polymorphisme.
  • Nous voulons pouvoir continuer à utiliser nos objets comme avant.


Comme le titre de cette sous-partie le stipule, nous allons créer l'interface Rintintin pour ensuite l'implémenter dans notre objet Chien.

Sous Eclipse, vous pouvez faire File / New / Interface, ou simplement cliquer sur la flèche noire à côté du C pour la création de classe, et choisir interface.


Voici son code :

Code : Java -  
1
2
3
4
5
6
7
 
public interface Rintintin{
 
   public void faireCalin();
   public void faireLechouille();
   public void faireLeBeau();
 
}


À présent, il ne nous reste plus qu'à implémenter l'interface dans notre classe Chien. Ce qui nous donne :
Code : Java -  
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
public class Chien extends Canin implements Rintintin {
 
        public Chien(){
                
        }
        public Chien(String couleur, int poids){
                this.couleur = couleur;
                this.poids = poids;
        }       
 
        
        void crier() {
                System.out.println("J'aboie sans raison ! ");
        }
        
        public void faireCalin() {
                System.out.println("Je te fais un GROS CÂLIN");
                
        }
        
        public void faireLeBeau() {
                System.out.println("Je fais le beau !");
                
        }
        
        public void faireLechouille() {
                System.out.println("Je fais de grosses léchouilles...");
                
        }
 
}

L'ordre des déclarations est PRIMORDIAL. Vous DEVEZ mettre l'expression d'héritage AVANT l'expression d'implémentation, SINON votre code ne compilera pas !


Voici un code que vous pouvez utiliser pour tester le polymorphisme de notre implémentation :
Code : Java -  
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
public class Test {
 
        /**
         * @param args
         */
        public static void main(String[] args) {
                //Les méthodes d'un chien 
                Chien c = new Chien("Gris bleuté", 20);
                c.boire();
                c.manger();
                c.deplacement();
                c.crier();
                System.out.println(c.toString());
                
                System.out.println("--------------------------------------------");
                //Les méthodes de l'interface
                c.faireCalin();
                c.faireLeBeau();
                c.faireLechouille();
                
                System.out.println("--------------------------------------------");
                //Utilisons le polymorphisme de notre interface
                Rintintin r = new Chien();
                r.faireLeBeau();
                r.faireCalin();
                r.faireLechouille();
                
        }
 
}


Objectif atteint !
Nous avons réussi à définir deux super classes afin de les utiliser comme super types et de jouir pleinement du polymorphisme !
Nous allons voir au chapitre suivant qu'il y a une façon d'utiliser les interfaces très intéressante ! Mais pour le moment, voyons un peu à quoi ressemble notre diagramme, à présent :


Nous voyons bien notre interface Rintintin ainsi que ses méthodes, et notre flèche pointillée qui se dirige vers notre interface signifie "implémente".
Nous pouvons lire Chien implemente Rintintin.

Bon : c'est l'heure d'une petite astuce de notre IDE préféré, il me semble...

Astuce d'Eclipse

Astuce 1



Je vous ai expliqué comment créer directement une interface.
Mais vous avez sans doute remarqué qu'une erreur persistante apparaît lorsque vous saisissez implements Rintintin après la déclaration de votre classe.

Je pense même que vous devez avoir une zolie croix rouge à côté du nom de la classe, comme celle-ci :

Cette erreur est dûe au fait que vous n'avez pas implémenté les méthodes de l'interface !

Cliquez sur cette croix rouge et choisissez l'option add unimplemented method : Eclipse ajoutera automatiquement toutes les méthodes à implémenter par la classe. 

Astuce 2



Je vais vous demander de faire appel à de vieux souvenirs provenant du chapitre précédent. Rappelez-vous l'astuce d'Eclipse afin de définir la super classe pour l'héritage. Eh bien Eclipse fait la même chose pour les interfaces...
Si, si, je vous assure. Regardez plutôt comment on crée une classe ChienSauvage héritant d' Animal et implémentant Rintintin.
On crée une nouvelle classe héritant d'Animal (vous savez faire) et avant de valider, regardez juste en dessous :


Cliquez à présent sur Add, vous arrivez sur une fenêtre où il vous est demandé quelle interface vous voulez implémenter. Commencez à taper Rintintin et, grâce à l'autocomplétion, Eclipse vous fait une sélection des interfaces disponibles dont Rintintin. Voyez plutôt :


Il ne vous reste plus qu'à cliquer sur OK, et voyez le résulat :


Votre classe implémente l'interface Rintintin.
Terminez l'opération : vous avez une classe qui hérite d'Animal ET qui implémente Rintintin. Celle-ci redéfinit toutes les méthodes abstraites de la classe abstraite ainsi que toutes les méthodes de l'interface.

On dit merci qui ?
Bon : je crois qu'un topo est indispensable.

Ce qu'il faut retenir

Alors, ici, la nouveauté vient de l'interface... Mais récapitulons un peu ce que nous avons vu.
  • Une interface est une classe 100 % abstraite.
  • Toutes les méthodes d'une interface n'ont pas de corps.
  • Une interface sert à définir un super type et à utiliser le polymorphisme.
  • Une interface s'implémente dans une classe en utilisant le mot clé implements.
  • Vous pouvez implémenter autant d'interfaces que vous voulez dans vos classes.
  • Vous devez redéfinir toutes les méthodes de l'interface (ou les interfaces) dans votre classe.


Prenez bien le temps de comprendre les deux chapitres que nous venons de voir.
Ceux-ci forment l'un des gros blocs du langage et vous verrez, lorsque nous aborderons les interfaces graphiques, que ces deux concepts sont omniprésents !
Pour le moment, nous allons continuer de voir les fondements de la programmation orientée objet, et poursuivons tout de suite par les exceptions !

// // 0 comments //

0 comments to "LECON 205"

Post a Comment

About This Blog

Aller au debut de la page