Nascondere nomi Java: The Hard Way

Ho un problema con il nascondere il nome che è estremamente difficile da risolvere. Ecco una versione semplificata che spiega il problema:

C'è una classe: org.A

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

Poi c'è una classe net.foo.X

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

E ora, ecco la classe problematica che eredita Ae vuole chiamarenet.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
    }
}

Come vedi, questo non è possibile. Non posso usare il nome semplice Xperché è nascosto da un tipo ereditato. Non posso utilizzare il nome completo net.foo.X, perché netè nascosto da un campo ereditato.

Solo la classe Bè nella mia base di codice; le classi net.foo.Xe org.Asono classi di libreria, quindi non posso modificarle!

La mia unica soluzione è questa: potrei chiamare un'altra classe che a sua volta chiama X.doSomething(); ma questa classe esisterebbe solo a causa del nome clash, che sembra molto disordinato! Non c'è soluzione in cui posso chiamare direttamente X.doSomething()da B.doSomething()?

In un linguaggio che consente di specificare lo spazio dei nomi globale, ad esempio global::in C # o ::in C ++, potrei semplicemente aggiungere netquesto prefisso globale, ma Java non lo consente.

Puoi eseguire il cast di un nullal tipo e quindi richiamare il metodo su quello (che funzionerà, poiché l'oggetto di destinazione non è coinvolto nel richiamo di metodi statici).

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

Questo ha i vantaggi di

• essere privi di effetti collaterali (un problema con la creazione di istanze net.foo.X),
• non richiedere la ridenominazione di nulla (quindi puoi dare il metodo nel Bnome che vuoi che abbia; ecco perché a import staticnon funzionerà nel tuo caso esatto),
• non richiede l'introduzione della classe delegato (anche se potrebbe essere una buona idea ...), e
• non richiede l'overhead o la complessità di lavorare con l'API di riflessione.

Lo svantaggio è che questo codice è davvero orribile! Per me, genera un avviso, e questa è una buona cosa in generale. Ma poiché sta aggirando un problema che altrimenti sarebbe del tutto impraticabile, l'aggiunta di un file

@SuppressWarnings("static-access")

in un punto di chiusura appropriato (minimo!) chiuderà il compilatore.

Probabilmente il modo più semplice (non necessariamente il più semplice) per gestirlo sarebbe con una classe delegato:

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

e poi ...

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

Questo è un po 'prolisso, ma molto flessibile: puoi farlo in modo che si comporti come preferisci; inoltre funziona più o meno allo stesso modo sia con staticmetodi che con oggetti istanziati

Maggiori informazioni sugli oggetti delegato qui: http://en.wikipedia.org/wiki/Delegation_pattern

Puoi utilizzare un'importazione statica:

import static net.foo.X.doSomething;

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

Attenzione a questo Be Anon contenere metodi denominatidoSomething

Il modo corretto di fare le cose sarebbe l'importazione statica, ma nello scenario peggiore in assoluto, POTRESTI costruire un'istanza della classe usando la riflessione se conosci il suo nome completo.

Java: newInstance di classe che non ha un costruttore predefinito

E quindi invoca il metodo sull'istanza.

Oppure, invoca il metodo stesso con la riflessione: invocando un metodo statico usando la riflessione

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

Naturalmente, queste sono ovviamente le ultime località.

Non proprio LA risposta, ma potresti creare un'istanza di X e chiamare il metodo statico su di essa. Sarebbe un modo (sporco lo ammetto) per chiamare il tuo metodo.

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

Non è necessario eseguire alcun cast o sopprimere strani avvisi o creare istanze ridondanti. Solo un trucco usando il fatto che puoi chiamare metodi statici della classe genitore tramite la sottoclasse. (Simile alla mia soluzione hacker qui .)

Basta creare una classe come questa

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

(Il costruttore privato in questa classe finale si assicura che nessuno possa creare accidentalmente un'istanza di questa classe.)

Quindi sei libero di chiamare X.doSomething()tramite esso:

    public class B extends A {

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

E se provassi a ottenere lo spazio dei nomi gobal dato che tutti i file si trovano nella stessa cartella. ( 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...

         }
     }

Questo è uno dei motivi per cui la composizione è preferibile all'eredità.

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

Userei il modello Strategia.

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

Ora hai anche disaccoppiato la tua dipendenza, quindi i tuoi unit test saranno più facili da scrivere.