Ocultación de nombres en Java: el camino difícil

Tengo un problema con la ocultación de nombres que es extremadamente difícil de resolver. Aquí hay una versión simplificada que explica el problema:

Hay una clase: org.A

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

Entonces hay una clase net.foo.X

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

Y ahora, aquí está la clase problemática que hereda Ay quiere llamarnet.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
    }
}

Como ve, esto no es posible. No puedo usar el nombre simple Xporque está oculto por un tipo heredado. No puedo usar el nombre completo net.foo.Xporque netestá oculto por un campo heredado.

Solo la clase Bestá en mi base de código; las clases net.foo.Xy org.Ason clases de biblioteca, ¡así que no puedo alterarlas!

Mi única solución se ve así: podría llamar a otra clase que a su vez llama X.doSomething(); pero esta clase solo existiría debido al choque de nombres, ¡que parece muy complicado! ¿No hay solución en la que puedo llamar directamente X.doSomething()desde B.doSomething()?

En un lenguaje que permite especificar el espacio de nombres global, por ejemplo, global::en C # o ::en C ++, podría simplemente prefijar neteste prefijo global, pero Java no lo permite.

Puede convertir un nullal tipo y luego invocar el método en eso (lo que funcionará, ya que el objeto de destino no está involucrado en la invocación de métodos estáticos).

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

Esto tiene los beneficios de

• estar libre de efectos secundarios (un problema con la creación de instancias net.foo.X),
• no requiere cambiar el nombre de nada (por lo que puede dar el método con Bel nombre que desea que tenga; es por eso import staticque a no funcionará en su caso exacto),
• no requiere la introducción de la clase de delegado (aunque eso podría ser una buena idea ...), y
• no requiere la sobrecarga o la complejidad de trabajar con la API de reflexión.

¡La desventaja es que este código es realmente horrible! Para mí, genera una advertencia y eso es algo bueno en general. Pero dado que está solucionando un problema que de otro modo no sería práctico, agregar un

@SuppressWarnings("static-access")

en un punto de inclusión apropiado (¡mínimo!) cerrará el compilador.

Probablemente la forma más simple (no necesariamente la más fácil) de administrar esto sería con una clase delegada:

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

y entonces ...

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

Esto es algo detallado, pero muy flexible: puede hacer que se comporte de la forma que desee; además, funciona de la misma manera tanto con staticmétodos como con objetos instanciados

Más sobre objetos delegados aquí: http://en.wikipedia.org/wiki/Delegation_pattern

Puede utilizar una importación estática:

import static net.foo.X.doSomething;

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

Tenga cuidado con eso By Ano contenga métodos con nombredoSomething

La forma correcta de hacer las cosas sería la importación estática, pero en el peor de los casos, PODRÍA construir una instancia de la clase usando la reflexión si conoce su nombre completo.

Java: newInstance de clase que no tiene un constructor predeterminado

Y luego invoca el método en la instancia.

O simplemente invoque el método en sí con reflexión: invocando un método estático usando reflexión

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

Por supuesto, estos son obviamente los últimos recursos.

No es realmente LA respuesta, pero puede crear una instancia de X y llamar al método estático en ella. Esa sería una forma (sucia, lo admito) de llamar a tu método.

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

No es necesario realizar ningún lanzamiento o suprimir advertencias extrañas o crear una instancia redundante. Solo un truco usando el hecho de que puede llamar a métodos estáticos de la clase principal a través de la subclase. (Similar a mi solución pirateada aquí ).

Solo crea una clase como esta

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

(El constructor privado en esta clase final se asegura de que nadie pueda crear accidentalmente una instancia de esta clase).

Entonces puedes llamar a X.doSomething()través de él:

    public class B extends A {

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

¿Qué sucede si intenta obtener el espacio de nombres global dado que todos los archivos están en la misma carpeta? ( 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...

         }
     }

Ésta es una de las razones por las que la composición es preferible a la herencia.

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

Usaría el patrón de estrategia.

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

Ahora también ha desacoplado su dependencia, por lo que sus pruebas unitarias serán más fáciles de escribir.