Java名称隐藏：艰难的道路

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

有一个类： 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()；但是此类仅由于名称冲突而存在，这看起来非常混乱！没有可以直接致电X.doSomething()给我的解决方案B.doSomething()吗？

用一种允许指定全局名称空间的语言（例如，global::在C＃或::C ++中），我可以简单地net在此全局前缀之前添加前缀，但是Java不允许这样做。

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

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

这样做的好处是

• 没有副作用（实例化存在问题net.foo.X），
• 不需要重命名（因此您可以使用B想要的名称来命名该方法；这就是为什么a import static在您的具体情况下不起作用的原因），
• 不需要引入委托类（尽管这可能是个好主意……），并且
• 不需要使用反射API的开销或复杂性。

缺点是这段代码真的太可怕了！对我来说，它会发出警告，这通常是一件好事。但是，由于它可以解决原本根本不切实际的问题，因此请添加

@SuppressWarnings("static-access")

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

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

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

您可以使用静态导入：

import static net.foo.X.doSomething;

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

当心这B和A不包含命名方法doSomething

正确的处理方式是静态导入，但是在绝对最坏的情况下，如果知道类的完全限定名称，则可以使用反射来构造类的实例。

Java：没有默认构造函数的class的newInstance

然后在实例上调用该方法。

或者，仅使用反射调用方法本身： 使用反射调用静态方法

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

当然，这些显然是不得已的方法。

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

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

无需执行任何强制转换或取消任何奇怪的警告或创建任何冗余实例。您可以通过子类调用父类的静态方法，这只是一个技巧。（类似于我这里的骇人听闻的解决方案。）

像这样创建一个类

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

（最后一个类中的私有构造函数确保没有人可以意外地创建此类的实例。）

然后，您可以X.doSomething()通过它自由打电话：

    public class B extends A {

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

如果在所有文件都位于同一文件夹中的情况下尝试获取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...

         }
     }

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

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

我会使用策略模式。

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

现在，您还解除了依赖关系的耦合，因此单元测试将更易于编写。