Discussion :

[maximus15]

Bonjour a tous,
je suis nouveau sur ce forum que je trouve formidable d'ailleurs, cependant j'ai une petite question en ce qui concerne les interfaces en java et les conventions
j'ai l'interface suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
public interface Expression<T,R> {
    public R eval( T val );
}

et dans mon cas j'implémente cette interface dans une classe anonyme interne comme cela:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
seq = seq.collect( new Expression<T,boolean>() {
    int i = 0; // le probleme est ici pour le i.
    public boolean eval( T x ) {
        boolean resultat = x.equals( seq2.at( i ) );
        i++;
        return resultat;
    }
} );

alors ne faites pas attention au collect, mais je voulais juste savoir si c'était élégant de déclarer le i dans la classe anonyme, ça m'a paru pas élégant de faire ça ( comme si je ne respectais pas l'interface Expression ).
mon code marche très bien, je veux juste l'optimiser.
en attendant vos réponses, merci a tous.

[Alain Defrance]

Bonjour et bienvenue,

Il n'y a pas de recommandation la dessus à ma conaissance et tu ne viole pas l'interface (la preuve en est que ça copile).
Une interface à pour but de regrouper un ensemble de type supportant une certaine responsabilité (et ton instance annonyme ici respecte tout à fait celà puisque tu implémente correctement la méthode).

Les classes anonymes sont rarement utilisés en production ou sur des points particuliers (lancement d'un thread par exemple, et encore ...). La lisibilité est affreuse et on perd totalement la mains sur l'instance.
Ton code est donc totalement valide mais cléer une classe a part ne serait pas du luxe .

[maximus15]

Merci beaucoup a toi Kazou, tout ce que tu dis est vrai sauf que parfois on a pas trop le choix que d'utiliser une classe anonyme interne.

[Alain Defrance]

Merci beaucoup a toi Kazou, tout ce que tu dis est vrai sauf que parfois on a pas trop le choix que d'utiliser une classe anonyme interne.

Je ne doute pas que ce que tu dis est fondé et fait certainement référence à une ou plusieurs éxperiences, mais peut-tu expliciter ?

[maximus15]

Salut a toi Kazou,

Je suis chargé de cours dans une université, et dans le cadre de mon cours (Modélisation formelle & spécification de logiciel), on a implémenté un collègue et moi les bibliothèque des collections OCL ( Set, Bag, Sequence et orderedSet ) en Java et sincèrement pour pouvoir passer des expressions a évaluer pour les quantificateurs(forAll, select, exists) on a pas d'autres choix que d'utiliser cette implémentation la.
Aussi, je ne suis pas un grand fan des swing de Java mais il m'est arrivé d'écrire du code pour faire des interfaces graphiques et la aussi si je ne me trompe pas, on a pas trop le choix d'utiliser ça pour ajouter des gestionnaires d'événements vu que pratiquement c'est toutes des interfaces.
Sur ce je te dis merci de ton attention et au plaisir de te lire

[Alain Defrance]

Bien évidement nous pouvons quoi qu'il en soit passer des Listeners sous forme de classes anonymes, et ce cas de figure se retrouve dans pas mal de domaines.

Ce n'est pas pour autant que c'est une pratique propre et évolutive. Il n'est pas rare de regrouper plusieurs listeners dans une classe qui va gérer plusieurs type d'évenements (drag and drop, action sur button, window, et j'en passe).

Toute classe anonyme est en fait un type dérivé. Si nous implémentons l'interface "MyInterface", et que nous souhaitons instancer un type MyInterface sans l'implémenter explicitement dans une classe, notre instance ainsi crée nne sera pas de type MyInterface, mais d'un type dérivé de celui ci. Notons que la signature d'un type (et donc la partie visible de l'extérieur), dépend du type, et non de l'instance. Au travers de classes anonymes nous pouvons nous retrouver a perdre une partie de la signature.

Je m'explique sous forme d'exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
interface MyInterface {
     void myMethod();
}
 
public class MyClass {
     public static main(String[] argv) {
          MyInterface mi = new MyInterface() {
               public void myMethod() { }
               public MyInterface myMethod2() { return this; }
          }.myMethod2(); // ici et ici seul cette méthode sera appelable.
 
          mi.myMethod2(); // ici c'est déjà trop tard car myMethod2 ne fait pas partie du type MyInterface et que la référence mi est de type MyInterface. 
     }
 
}

Je cherche par là à mettre en évidence qu'une classe anonyme revient à créer un type a usage unique (les implémentations ne seront pas réutilisables plus tard, du moins pas sur une nouvelle instance), et que dans tous les cas il sera toujours possible de passer par une implémentation concrète de cette interface.
Si je me trompe (totalement possible), je veux bien voir un exemple de code où il est impossible de se passer d'implémentation anonyme.