Discussion :

[SasakiKojiro]

Bonjour,

Tout d'abord, désolé pour le titre confus, je ne sais trop comment intituler correctement ce soucis...
Prenons l'exemple suivant :

Code Java :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
package test;
 
public class ExtendsStaticTest
{
 
    /**
     * @param args
     */
    public static void main(String[] args)
    {
        B.foo();
        A.getB().foo();
    }
}

Code Java :

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
 
package test;
 
public class A
{
 
    protected static void foo()
    {
        System.out.println("bar");
    }
 
    public static A getB()
    {
        return new B();
    }
}

Code Java :

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

1
2
3
4
5
6
7
8
9
10
11
 
package test;
 
public class B
    extends A
{
    protected static void foo()
    {
        System.out.println("barB");
    }
}

Selon moi, l'appel à A.getB() me retourne une instance de B, instance dont la classe hérite de A.
A.getB().foo() fait cependant appel à la méthode de la classe A...

Pourquoi et comment faire pour que ce soit la méthode B.foo() qui soit appelée ?


Le soucis réel caché derrière cet ECM est qu'au lieu d'avoir A.getB(), j'ai A.getUneClasse() dont le retour peut être soit une instance de A, soit une instance de B; où B s'agirait d'une classe surchargée par un utilisateur.


Avez vous des explications à me fournir sur ce comportement que je ne comprends pas ?

Merci

[Pill_S]

Le polymorphisme ne s'applique pas dans le cas de méthodes statiques. C'est le type déclaré à la compilation qui est exécuté, pas le type réel.

Early binding vs late binding ==> le static est linké, figé dans le marbre, au moment de la compilation. Tout comme d'ailleurs le polymorphisme paramètrique (avoir 2 signatures void foo(Object o) et void foo(String s), que se passe-t-il quand on invoque avec une variable de type Object qui contient en réalité une String??)

[SasakiKojiro]

Merci pour ta réponse.
Du coup, si je te comprends bien, le soucis est lié au fait que ma méthode A.getB() soit statique...

Admettons que je crée la fonction suivante dans la classe A

Code Java :

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

1
2
3
4
5
 
    public A getBNoStatic()
    {
        return new B();
    }

L'appel à new A().getBNoStatic().foo(); ne devrait-il pas alors valoir la même chose que B.foo(); ?
Pourtant cela me renvoie vers A.foo();

J'ai actuellement la main sur getB() de la classe A ainsi que sur la classe B.
Par contre, je n'ai pas la main sur le reste de la classe A pour raison de rétrocompatibilité...
foo() est une méthode statique et je ne peux pas le modifier.

Merci


Edit : Pas sûr d'avoir tapé à coté de ton explication... en fait, A.getB() pourrait ou non être statique on s'en fiche mais c'est foo() qui, étant statique, empêche d'appeler correctement A.foo() ou B.foo() ?

Ai-je un moyen de faire autrement ?

[thelvin]

Hello

[...] en fait, A.getB() pourrait ou non être statique on s'en fiche mais c'est foo() qui, étant statique, empêche d'appeler correctement A.foo() ou B.foo() ?

Yup. Cela dit, c'est une mauvaise chose d'appeler A.getB(). Une méthode statique s'appelle en fonction de son nom de classe, pas d'un objet.

Ai-je un moyen de faire autrement ?

B.foo(), et puis c'est tout. De toute façon c'est elle que tu veux appeler, pas une autre, alors pourquoi chercher ailleurs ?

[Pill_S]

Tu pourrais forcer via un cast, mais c'est moche... ((B)A.getBNoStatic()).foo()En plus c'est vrai, si c'est statique, faut invoquer de manière statique... en référençant la classe et pas une instance

[SasakiKojiro]

Hello
B.foo(), et puis c'est tout. De toute façon c'est elle que tu veux appeler, pas une autre, alors pourquoi chercher ailleurs ?

Par défaut, la classe A existe et est la référence. Il se peut que pour un besoin spécifique, l'utilisateur ait définit une classe B et souhaite ne pas appeler A.foo() mais B.foo()
Donc s'il a défini B, je dois utiliser B.
Au final, je sais seulement que je vais appeler la méthode foo() mais pour certains utilisateurs ça viendra de A, pour d'autre de B.

Tu pourrais forcer via un cast, mais c'est moche... ((B)A.getBNoStatic()).foo()En plus c'est vrai, si c'est statique, faut invoquer de manière statique... en référençant la classe et pas une instance

Pareil, si je force le cast, j'empêche le fait de pouvoir avoir A.foo().
Je suis désolé, je suis pas vraiment clair... J'avais expliqué que je n'ai pas vraiment de A.getB() mais un A.getUneClasse() et que, si l'utilisateur a défini la classe B, la méthode me retourne B; A sinon.

A n'étant pas un B, ((B)A.getBNoStatic()).foo() me renverra une classCastException

[Nico02]

Salut,

Je sais pas si j'ai bien compris mais pour moi le seul moyen c'est d'utiliser la réflexion sur l'appel de la méthode.

Ex:

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 class A
{
 public static void foo() { System.out.println( "A" ); }
}
 
public class B extends A
{
 public static void foo() { System.out.println( "B" ); }
}
 
A a = new A();
A b = new B();
Class<?> clazz;
 
clazz = Class.forName( a.getClass().getName() );
 
Method method = clazz.getMethod( "foo", null );
 
method.invoke( null, null ); // Donne A.foo()
 
clazz = Class.forName( b.getClass().getName() );
method = clazz.getMethod( "foo", null );
method.invoke( null, null ); // Donne B.foo()

Dans le cas où B ne contient pas la méthode foo(), alors le deuxième appel renvoie A.foo()

[Pill_S]

Oui bonne idée la réflexion, bien vu...

Mais fondamentalement, c'est quand même très faux de vouloir un mécanisme OO et d'avoir tout en statique... tu peux pas challenger la personne en charge de ton api pour peut-être enlever le statique?

[Nico02]

Oui bonne idée la réflexion, bien vu...

Mais fondamentalement, c'est quand même très faux de vouloir un mécanisme OO et d'avoir tout en statique... tu peux pas challenger la personne en charge de ton api pour peut-être enlever le statique?

Je suis bien d'accord.. Après j'imagine que personne ne respecte vraiment tous les paradigmes OO à la lettre donc bon..

[Pill_S]

Après j'imagine que personne ne respecte vraiment tous les paradigmes OO à la lettre donc bon..

oui c'est sûr... mais ça vaut le coup de demander/confirmer... peut-être que le gars peut rajouter une méthode non-statique à côté, qui s'occupe d'invoquer la méthode statique qui-va-bien? genre:

Code :

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

1
2
3
4
5
6
7
8
9
 
class A {
    static void foo() {}
    public void fooPasCassé() { A.foo(); }
}
class B extends A {
    static void foo() {}
    public void fooPasCassé() { B.foo(); }
}

... et du coup polymorphisme-powered...

Souvent, on ne peut pas enlever ni changer la signature des méthodes d'une api publiée. Mais c'est rarissime de ne pas pouvoir en ajouter

j'ai souvent eu des soucis avec de la réflexion mal placée... c'est puissant mais ça a son lot de défauts... et si on peut s'en passer... mazeltov!

[tchize_]

Merci pour ta réponse.
Du coup, si je te comprends bien, le soucis est lié au fait que ma méthode A.getB() soit statique...

Non, il est lié au fait que la méthode foo() soit statique. Une méthode statique s'appelle via la classe et non via l'instance. C'est tout simplement à considérer comme une erreur d'écrire

Code :

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

monInstance.foo()

si foo est statique et un bon ide va te mettre un bon gros warning là dessus.

Ai-je un moyen de faire autrement ?

De la manière la plus simple, avec un if vu ton explication.

Code :

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

1
2
3
4
5
6
 
if (a instanceof b){
 B.foo();
} else {
 A.foo();
}

Par défaut, la classe A existe et est la référence. Il se peut que pour un besoin spécifique, l'utilisateur ait définit une classe B et souhaite ne pas appeler A.foo() mais B.foo()
Donc s'il a défini B, je dois utiliser B.

Je vois déjà deux chose:
foo() dois pouvoir être redéfini
l'appel foo() est fonction de l'instance de A/B dont on dispose à l'instant T
deux raison qui font que foo n'a aucune raison d'être statique. Je voudrais quand même bien voir le cas concret car soit t'as mal compris l'utilisation de A, soit A a été très très mal architecturée.

Salut,

Je sais pas si j'ai bien compris mais pour moi le seul moyen c'est d'utiliser la réflexion sur l'appel de la méthode.

Non seulement ce code va galérer, faire sauter toutes les vérifications du compilateur et être complexe à réaliser en prenant tout en compte (on fait quoi des Proxy dynamiques par exemple?), mais la reflection ne devrait pas être utilisée pour palier un problème de design.

Faudrait plus de code pour fournir une solution propre et si on va pour le moche, autant y aller avec un if sur toutes les sous classes connues plutot que de passer par une reflection complexe et douloureuse.

[Pill_S]

De la manière la plus simple, avec un if vu ton explication.

Code :

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

1
2
3
4
5
6
 
if (a instanceof b){
 B.foo();
} else {
 A.foo();
}

comme je l'ai compris, B n'est pas connu à la compilation... correct?

[Nico02]

comme je l'ai compris, B n'est pas connu à la compilation... correct?

C'est ce que j'ai compris aussi.

mais la reflection ne devrait pas être utilisée pour palier un problème de design

J'ai pas dit non plus que c'était the best solution ever. Mais on sait tous que parfois on a pas vraiment le choix..

Après comme tu le signales, il faudrait un exemple plus concret pour voir si il y a mieux à faire.

[tchize_]

ouais sauf que là visiblement, j'ai l'impression que c'est lui qui définis dans son code qu'on peux étendre une fonction statique, ça n'a jamais été prévu par la librairie de base, donc il se fourvoie donc il peut se corriger plutot que de sortir cette horreur qui va pêter de partout.