Java名称隐藏：艰难的方式

Question

我有一个非常难以解决的名称隐藏问题。这是解释问题的简化版本：

有一个类：org.A

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

然后有一个类net.foo.X

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

现在，这是继承自 A 并想调用 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
    }
}

如您所见，这是不可能的。我不能使用简单的名称X，因为它被继承的类型隐藏了。我不能使用完全限定名称net.foo.X，因为net 被继承的字段隐藏。

我的代码库中只有 B 类； net.foo.X 和 org.A 类是库类，所以我无法更改它们！

我唯一的解决方案如下所示： 我可以调用另一个类，然后调用X.doSomething()；但是这个类只会因为名字冲突而存在，看起来很乱！有没有可以直接从B.doSomething()调用X.doSomething()的解决方案？

在允许指定全局命名空间的语言中，例如 C# 中的 global:: 或 C++ 中的 ::，我可以简单地为 net 加上这个全局前缀，但 Java 不允许这样做。

Answer 1

您可以将 null 强制转换为该类型，然后调用该类型的方法（这将起作用，因为目标对象不参与静态方法的调用）。

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

这有以下好处

• 无副作用（实例化 net.foo.X 时出现问题），
• 不需要重命名任何内容（因此您可以为 B 中的方法指定您想要的名称；这就是为什么 import static 不适用于您的具体情况），
• 不需要引入委托类（尽管这可能是个好主意……），并且
• 不需要使用反射 API 的开销或复杂性。

缺点是这段代码真的很糟糕！对我来说，它会产生警告，总的来说这是一件好事。但由于它正在解决一个完全不切实际的问题，因此添加一个

@SuppressWarnings("static-access")

在适当的（最小的！）封闭点将关闭编译器。

Answer 2

可能最简单（不一定是最简单）的管理方法是使用委托类：

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

然后……

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

这有点冗长，但非常灵活——你可以让它以你想要的任何方式运行；此外，它与 static 方法和实例化对象的工作方式几乎相同

更多关于委托对象的信息：http://en.wikipedia.org/wiki/Delegation_pattern

Answer 3

您可以使用静态导入：

import static net.foo.X.doSomething;

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

注意B 和A 不包含名为doSomething 的方法

Answer 4

做事的正确方法是静态导入，但在绝对最坏的情况下，如果你知道它的完全限定名，你可以使用反射构造一个类的实例。

Java: newInstance of class that has no default constructor

然后调用实例上的方法。

或者，只需使用反射调用方法本身： Invoking a static method using reflection

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

当然，这些显然是最后的手段。

Answer 5

不是真正的答案，但您可以创建 X 的一个实例并在其上调用静态方法。 那将是调用您的方法的一种方式（我承认很脏）。

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

Answer 6

无需进行任何强制转换或抑制任何奇怪的警告或创建任何冗余实例。只是一个技巧，您可以通过子类调用父类静态方法。 （类似于我的 hackish 解决方案 here。）

创建一个这样的类

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

（这个最终类中的私有构造函数确保没有人会意外地创建这个类的实例。）

那么你就可以通过它拨打X.doSomething()了：

    public class B extends A {

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

Answer 7

假设所有文件都在同一个文件夹中，如果您尝试获取 gobalnamespace 会怎样。 (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...

         }
     }

Answer 8

这是组合优于继承的原因之一。

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

Answer 9

我会使用策略模式。

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

现在您还解耦了依赖项，因此您的单元测试将更容易编写。