Masquage de nom Java: la manière difficile

J'ai un problème de masquage de nom qui est extrêmement difficile à résoudre. Voici une version simplifiée qui explique le problème:

Il y a une classe: org.A

package org;
public class A{
     public class X{...}
     ...
     protected int net;
}

Puis il y a une classe net.foo.X

package net.foo;
public class X{
     public static void doSomething();
}

Et maintenant, voici la classe problématique qui hérite Aet veut appelernet.foo.X.doSomething()

package com.bar;
class B extends A {

    public void doSomething(){
        net.foo.X.doSomething(); // doesn't work; package net is hidden by inherited field
        X.doSomething(); // doesn't work; type net.foo.X is hidden by inherited X
    }
}

Comme vous le voyez, ce n'est pas possible. Je ne peux pas utiliser le nom simple Xcar il est masqué par un type hérité. Je ne peux pas utiliser le nom complet net.foo.X, car il netest masqué par un champ hérité.

Seule la classe Best dans ma base de code; les classes net.foo.Xet org.Asont des classes de bibliothèque, donc je ne peux pas les modifier!

Ma seule solution ressemble à ceci: je pourrais appeler une autre classe qui à son tour appelle X.doSomething(); mais cette classe n'existerait qu'à cause du nom clash, qui semble très désordonné! Yat - il pas de solution dans laquelle je peux appeler directement à X.doSomething()partir B.doSomething()?

Dans un langage qui permet de spécifier l'espace de noms global, par exemple, global::en C # ou ::en C ++, je pourrais simplement préfixer netavec ce préfixe global, mais Java ne le permet pas.

Vous pouvez convertir a nullen type, puis appeler la méthode sur celui-ci (ce qui fonctionnera, car l'objet cible n'est pas impliqué dans l'appel des méthodes statiques).

((net.foo.X) null).doSomething();

Cela a les avantages de

• être sans effet secondaire (problème d'instanciation net.foo.X),
• ne nécessitant pas de renommer quoi que ce soit (vous pouvez donc donner à la méthode Ble nom que vous voulez; c'est pourquoi a import staticne fonctionnera pas dans votre cas exact),
• ne nécessitant pas l'introduction de classe de délégué (bien que cela puisse être une bonne idée…), et
• ne nécessitant pas la surcharge ou la complexité de travailler avec l'API de réflexion.

L'inconvénient est que ce code est vraiment horrible! Pour moi, cela génère un avertissement, et c'est une bonne chose en général. Mais comme cela fonctionne autour d'un problème qui est autrement tout à fait irréalisable, l'ajout d'un

@SuppressWarnings("static-access")

à un point englobant approprié (minimal!) fermera le compilateur.

Le moyen le plus simple (pas nécessairement le plus simple) de gérer cela serait probablement d'utiliser une classe déléguée:

import net.foo.X;
class C {
    static void doSomething() {
         X.doSomething();
    }
}

puis ...

class B extends A {
    void doX(){
        C.doSomething();
    }
}

C'est quelque peu verbeux, mais très flexible - vous pouvez le faire se comporter comme vous le souhaitez; de plus, il fonctionne à peu près de la même manière avec les staticméthodes et les objets instanciés

Plus d'informations sur les objets délégués ici: http://en.wikipedia.org/wiki/Delegation_pattern

Vous pouvez utiliser une importation statique:

import static net.foo.X.doSomething;

class B extends A {
    void doX(){
        doSomething();
    }
}

Attention à cela Bet Ane contiennent pas de méthodes nomméesdoSomething

La bonne façon de faire les choses serait l'importation statique, mais dans le pire des cas, vous POUVEZ construire une instance de la classe en utilisant la réflexion si vous connaissez son nom complet.

Java: newInstance de classe qui n'a pas de constructeur par défaut

Et puis invoquez la méthode sur l'instance.

Ou, appelez simplement la méthode elle-même avec la réflexion: Appel d'une méthode statique à l'aide de la réflexion

Class<?> clazz = Class.forName("net.foo.X");
Method method = clazz.getMethod("doSomething");
Object o = method.invoke(null);

Bien sûr, ce sont évidemment les derniers recours.

Pas vraiment LA réponse mais vous pouvez créer une instance de X et appeler la méthode statique dessus. Ce serait une façon (sale je l'admets) d'appeler votre méthode.

(new net.foo.X()).doSomething();

Il n'est pas nécessaire de lancer ou de supprimer les avertissements étranges ou de créer une instance redondante. Juste une astuce utilisant le fait que vous pouvez appeler des méthodes statiques de classe parent via la sous-classe. (Similaire à ma solution hackish ici .)

Créez simplement une classe comme celle-ci

public final class XX extends X {
    private XX(){
    }
}

(Le constructeur privé de cette classe finale s'assure que personne ne peut créer accidentellement une instance de cette classe.)

Ensuite, vous êtes libre d'appeler X.doSomething()via:

    public class B extends A {

        public void doSomething() {
            XX.doSomething();
        }

Que faire si vous essayez d'obtenir le gobalnamespace étant donné que tous les fichiers sont dans le même dossier. ( http://www.beanshell.org/javadoc/bsh/class-use/NameSpace.html )

    package com.bar;
      class B extends A {

       public void doSomething(){
         com.bar.getGlobal().net.foo.X.doSomething(); // drill down from the top...

         }
     }

C'est l'une des raisons pour lesquelles la composition est préférable à l'héritage.

package com.bar;
import java.util.concurrent.Callable;
public class C implements Callable<org.A>
{
    private class B extends org.A{
    public void doSomething(){
        C.this.doSomething();
    }
    }

    private void doSomething(){
    net.foo.X.doSomething();
    }

    public org.A call(){
    return new B();
    }
}

J'utiliserais le modèle de stratégie.

public interface SomethingStrategy {

   void doSomething();
}

public class XSomethingStrategy implements SomethingStrategy {

    import net.foo.X;

    @Override
    void doSomething(){
        X.doSomething();
    }
}

class B extends A {

    private final SomethingStrategy strategy;

    public B(final SomethingStrategy strategy){
       this.strategy = strategy;
    }

    public void doSomething(){

        strategy.doSomething();
    }
}

Maintenant, vous avez également découplé votre dépendance, de sorte que vos tests unitaires seront plus faciles à écrire.