Java Name Hiding: Der harte Weg

Ich habe ein Problem mit dem Verstecken von Namen, das extrem schwer zu lösen ist. Hier ist eine vereinfachte Version, die das Problem erklärt:

Es gibt eine Klasse: org.A

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

Dann gibt es eine Klasse net.foo.X

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

Und jetzt ist hier die problematische Klasse, die von erbt Aund anrufen möchtenet.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
    }
}

Wie Sie sehen, ist dies nicht möglich. Ich kann den einfachen Namen nicht verwenden, Xda er von einem geerbten Typ ausgeblendet wird. Ich kann den vollständig qualifizierten Namen nicht verwenden net.foo.X, da er netdurch ein geerbtes Feld ausgeblendet wird.

Nur die Klasse Bbefindet sich in meiner Codebasis. die Klassen net.foo.Xund org.Asind Bibliotheksklassen, also kann ich sie nicht ändern!

Meine einzige Lösung sieht so aus: Ich könnte eine andere Klasse aufrufen, die wiederum aufruft X.doSomething(); aber diese Klasse würde nur wegen des Namenskonflikts existieren, der sehr chaotisch erscheint! Gibt es keine Lösung , in der ich direkt anrufen kann X.doSomething()aus B.doSomething()?

In einer Sprache, in der der globale Namespace angegeben werden kann, z. B. global::in C # oder ::C ++, könnte ich einfach netdieses globale Präfix voranstellen, aber Java lässt dies nicht zu.

Sie können ein nullin den Typ umwandeln und dann die Methode darauf aufrufen (was funktioniert, da das Zielobjekt nicht am Aufruf statischer Methoden beteiligt ist).

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

Dies hat die Vorteile von

• frei von Nebenwirkungen sein (ein Problem beim Instanziieren net.foo.X),
• Sie müssen nichts umbenennen (damit Sie die Methode in Bdem Namen angeben können, den Sie möchten; deshalb import staticfunktioniert a in Ihrem genauen Fall nicht).
• keine Einführung einer Delegiertenklasse erforderlich (obwohl dies eine gute Idee sein könnte…), und
• Der Aufwand oder die Komplexität der Arbeit mit der Reflection-API sind nicht erforderlich.

Der Nachteil ist, dass dieser Code wirklich schrecklich ist! Für mich erzeugt es eine Warnung, und das ist im Allgemeinen eine gute Sache. Aber da es sich um ein Problem handelt, das ansonsten völlig unpraktisch ist, fügen Sie a hinzu

@SuppressWarnings("static-access")

An einem geeigneten (minimalen!) Einschlusspunkt wird der Compiler heruntergefahren.

Der wahrscheinlich einfachste (nicht unbedingt einfachste) Weg, dies zu verwalten, wäre eine Delegatenklasse:

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

und dann ...

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

Dies ist etwas ausführlich, aber sehr flexibel - Sie können dafür sorgen, dass es sich so verhält, wie Sie es möchten. Außerdem funktioniert es sowohl mit staticMethoden als auch mit instanziierten Objekten ähnlich

Weitere Informationen zum Delegieren von Objekten finden Sie hier: http://en.wikipedia.org/wiki/Delegation_pattern

Sie können einen statischen Import verwenden:

import static net.foo.X.doSomething;

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

Beachten Sie dies Bund Aenthalten Sie keine benannten MethodendoSomething

Die richtige Vorgehensweise wäre der statische Import. Im schlimmsten Fall KÖNNTEN Sie jedoch eine Instanz der Klasse mithilfe von Reflection erstellen, wenn Sie den vollständig qualifizierten Namen kennen.

Java: newInstance einer Klasse ohne Standardkonstruktor

Rufen Sie dann die Methode für die Instanz auf.

Oder rufen Sie einfach die Methode selbst mit Reflektion auf: Rufen Sie eine statische Methode mit Reflektion auf

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

Dies sind natürlich die letzten Mittel.

Nicht wirklich DIE Antwort, aber Sie könnten eine Instanz von X erstellen und die statische Methode darauf aufrufen. Das wäre eine Möglichkeit (schmutzig, gebe ich zu), Ihre Methode aufzurufen.

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

Es ist nicht erforderlich, seltsame Warnungen auszuführen oder zu unterdrücken oder redundante Instanzen zu erstellen. Nur ein Trick mit der Tatsache, dass Sie statische Methoden der übergeordneten Klasse über die Unterklasse aufrufen können. (Ähnlich wie bei meiner hackigen Lösung hier .)

Erstellen Sie einfach eine Klasse wie diese

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

(Der private Konstruktor in dieser letzten Klasse stellt sicher, dass niemand versehentlich eine Instanz dieser Klasse erstellen kann.)

Dann können Sie darüber anrufen X.doSomething():

    public class B extends A {

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

Was ist, wenn Sie versuchen, den Gobalnamespace abzurufen, da sich alle Dateien im selben Ordner befinden? ( 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...

         }
     }

Dies ist einer der Gründe, warum die Zusammensetzung der Vererbung vorzuziehen ist.

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

Ich würde das Strategiemuster verwenden.

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

Jetzt haben Sie auch Ihre Abhängigkeit entkoppelt, sodass Ihre Komponententests einfacher zu schreiben sind.