Скрытие имени 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 этого не позволяет.

Вы можете привести 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<?> 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();
        }

Что, если вы попытаетесь получить глобальное пространство имен, учитывая, что все файлы находятся в одной папке. ( 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();
    }
}

Теперь вы также развязали свою зависимость, поэтому ваши модульные тесты будет проще писать.