Ukrywanie nazw w Javie: trudny sposób

Mam problem z ukrywaniem nazwy, który jest niezwykle trudny do rozwiązania. Oto uproszczona wersja, która wyjaśnia problem:

Jest klasa: org.A

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

Potem jest klasa net.foo.X

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

A teraz mamy problematyczną klasę, która dziedziczy Ai chce zadzwonićnet.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
    }
}

Jak widzisz, nie jest to możliwe. Nie mogę użyć prostej nazwy, Xponieważ jest ona ukryta przez dziedziczony typ. Nie mogę użyć w pełni kwalifikowanej nazwy net.foo.X, ponieważ netjest ona ukryta przez dziedziczone pole.

Tylko klasa Bjest w mojej bazie kodu; klasy net.foo.Xi org.Asą klasami bibliotecznymi, więc nie mogę ich zmieniać!

Moje jedyne rozwiązanie wygląda następująco: mógłbym wywołać inną klasę, która z kolei wywołuje X.doSomething(); ale ta klasa istniałaby tylko z powodu konfliktu nazw, który wydaje się bardzo niechlujny! Czy istnieje żadne rozwiązanie, w którym można wywołać bezpośrednio X.doSomething()z B.doSomething()?

W języku, który umożliwia określenie globalnej przestrzeni nazw, np. global::W C # lub ::C ++, mógłbym po prostu poprzedzić netten globalny prefiks, ale Java na to nie pozwala.

Możesz rzutować nullna typ, a następnie wywołać metodę na tym (co będzie działać, ponieważ obiekt docelowy nie jest zaangażowany w wywołanie metod statycznych).

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

Ma to zalety

• brak efektów ubocznych (problem z tworzeniem instancji net.foo.X),
• nie wymaga zmiany nazwy czegokolwiek (więc możesz podać metodę w Bnazwie, którą chcesz, aby miała; dlatego import staticw Twoim przypadku nie zadziała),
• niewymagające wprowadzenia klasy delegatów (choć może to być dobry pomysł…) i
• nie wymaga nakładów pracy ani złożoności pracy z interfejsem API odbicia.

Wadą jest to, że ten kod jest naprawdę okropny! Dla mnie generuje ostrzeżenie i ogólnie to dobrze. Ale ponieważ rozwiązuje problem, który w przeciwnym razie jest całkowicie niepraktyczny, dodanie pliku

@SuppressWarnings("static-access")

w odpowiednim (minimalnym!) punkcie zamykającym zamknie kompilator.

Prawdopodobnie najprostszym (niekoniecznie najłatwiejszym) sposobem radzenia sobie z tym byłoby użycie klasy delegatów:

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

i wtedy ...

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

Jest to nieco rozwlekłe, ale bardzo elastyczne - możesz sprawić, by zachowywał się w dowolny sposób; ponadto działa w podobny sposób zarówno z staticmetodami, jak i obiektami, których instancje są tworzone

Więcej o obiektach delegatów tutaj: http://en.wikipedia.org/wiki/Delegation_pattern

Możesz użyć importu statycznego:

import static net.foo.X.doSomething;

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

Uważaj na to Bi Anie używaj nazwanych metoddoSomething

Właściwym sposobem wykonywania tego zadania byłby import statyczny, ale w absolutnie najgorszym przypadku MOŻESZ skonstruować instancję klasy przy użyciu funkcji Refleksja, jeśli znasz jej w pełni kwalifikowaną nazwę.

Java: newInstance klasy, która nie ma domyślnego konstruktora

Następnie wywołaj metodę w instancji.

Lub po prostu wywołaj samą metodę z refleksją: wywołanie metody statycznej przy użyciu odbicia

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

Oczywiście są to oczywiście ostateczności.

Nie do końca jest to odpowiedź, ale możesz stworzyć instancję X i wywołać na niej metodę statyczną. To byłby sposób (przyznaję nieprzyzwoity) na nazwanie twojej metody.

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

Nie ma potrzeby rzucania ani tłumienia dziwnych ostrzeżeń ani tworzenia zbędnych instancji. Tylko sztuczka wykorzystująca fakt, że możesz wywołać statyczne metody klasy nadrzędnej za pośrednictwem podklasy. (Podobne do mojego hackerskiego rozwiązania tutaj .)

Po prostu stwórz taką klasę

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

(Prywatny konstruktor w tej ostatniej klasie zapewnia, że ​​nikt nie może przypadkowo utworzyć wystąpienia tej klasy).

Następnie możesz zadzwonić X.doSomething()za jego pośrednictwem:

    public class B extends A {

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

Co jeśli spróbujesz uzyskać przestrzeń nazw gobal, biorąc pod uwagę, że wszystkie pliki znajdują się w tym samym folderze. ( 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...

         }
     }

Jest to jeden z powodów, dla których kompozycja jest lepsza niż dziedziczenie.

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();
    }
}

Użyłbym wzorca strategii.

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();
    }
}

Teraz oddzieliłeś również swoją zależność, więc testy jednostkowe będą łatwiejsze do napisania.