Discussion :

[Chabanus]

Bonjour,

Je tombe sur un problème que je n'arrive pas à résoudre seul. J'ai une classe abstraite qui a plusieurs méthodes et j'ai une classe qui étends cette classe abstraite. La question est comment je peux vérifier au niveau de cette classe abstraite si une de ses méthodes a été redéfinie ?

Je suis sous un environnement J2EE 1.4.

Merci d'avance.

Cordialement.

[ray_fab]

Je sais pas ce que tu veux faire, mais tu peux faire un décorateur comme ça tu vérifies si la valeur par défaut de ta méthode change suivant la classe dérivée cela signifie que la méthode a été redéfinie.

[thelvin]

En principe tu ne peux pas : ça nécessiterait d'analyser toutes les classes qui descendent de ta classe abstraite. En en principe, il n'y a aucun moyen d'avoir l'ensemble des classes qui étendent une autre classe.

Le plus simple est de garantir que ce n'est pas le cas : en déclarant final toutes les méthodes.

[CyberChouan]

Manuellement, ça risque d'être un peu compliqué. Cependant, certains environnements de développement évolués (Eclipse, IntelliJ, Netbeans notamment) peuvent t'aider dans cette recherche.

[Chabanus]

Merci pour vos réponses.

Pour vous expliquer un peu le contexte, voici un exemple de ce que je fais :

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
16
17
18
19
20
21
22
23
24
public interface I{
  public void a();
  public void b();
}
 
public abstract class A implements I{
 
  private int val = 0;
 
  public void a(){
     val = 1;
  }
 
  public void b(){
     val = 2;
  }
}
 
widget.addA(new A(){
 
   public void a(){
      bidule = 4;
   }
});

Comme vous pouvez le remarquer dans cet exemple, on ne peut pas deviner quelle méthode a été redéfinie. Je ne peux donc plus récupérer la valeur de val qui est égale à 1 !

Utiliser un design pattern comme Décorateur ne me servira pas dans mon contexte.

Peut être existe-t-il un moyen de le deviner avec un peu de réflexivité ? Tout en étant dans un environnement J2EE 1.4 ?

Des suggestions ? Merci.

[tchize_]

La question n'est pas "comment le détecter" mais plutot "pourquoi tu aurais besoin de le savoir"?

Je vois trois possibilités

1) tu veux garder le comportement de a() de la classe abstraite -> dans ce cas tu rend cette méthode final et c'est réglé
2) tu veux qu'on puisse redéfinir le comportement de a(), dans ce cas, fait confiance à tes enfants, ce sont des grande garçons, si il te disent que a() c'est bidule, alors a sera bidule
3) t'as besoin dans l'enfant d'appeler la méthode du parent. Alors c'est

Code :

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

1
2
3
4
5
6
7
widget.addA(new A(){
 
   public void a(){
      super.a();
      bidule = 4;
   }
});

[miaous]

Salut

Tu peux utiliser l’introspection pour savoir si ta méthode à était redéfini.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
for (Class cl = getClass();
 cl != MASUPERCLASS.class;
 cl = cl.getSuperclass())
 {
 try {

 Class[] params = {TYPEARG1.class , TYPEARG2.class , .. ,TYPEARGN.class }
 cl.getDeclaredMethod("NOMDELAMETHODE", params);
 return Boolean.TRUE;
 } catch (NoSuchMethodException ex) {
 }
 }
 return Boolean.FALSE;