Блог

Я хочу иметь иерархию типов, в которой только Foo объекты контролируют создание Bar объектов. Например:

 public abstract class Foo<F extends Foo<F>> {
    public abstract  Bar<F> makeBar();
}

public abstract class Bar<F extends Foo<F>> {}
  

Теперь подкласс Foo мог бы реализовать подкласс Bar и вернуть его обратно:

 public class FooImpl extends Foo<FooImpl> {

    private static class BarImpl extends Bar<FooImpl> {}

    @Override
    public Bar<FooImpl> makeBar() { return new BarImpl(); }
}
  

Однако это все еще позволяет создавать Bar объекты в другом месте:

 public class FakeBar extends Bar<FooImpl> {}
  

Как я могу ограничить Bar<FooImpl> (используя только систему типов, а не проверки во время выполнения) таким образом, чтобы он должен создаваться экземпляром FooImpl и не может быть создан ни в каком другом месте?

Это не то, что система типов может (или должна) делать. Вы хотите ограничить доступ, используйте модификаторы доступа Java. Но я не думаю, что они также могут реализовать ваши очень специфические и необычные требования.

На самом деле, я не думаю, что они вообще могут быть реализованы: вы хотите, чтобы класс был общедоступным и не был окончательным, но при этом позволял вызывать его конструкторы и распространять его только на определенный класс и его подклассы?

Извините, не могу сделать. В любом случае, какой в этом был бы смысл?

Это не работает (с ограничением: введите только system, никаких проверок во время выполнения). Мы можем либо запретить создание подклассов вообще ( final класс), либо разрешить его. Если (общедоступный) класс не является окончательным, любой другой класс может быть подклассом.

Вы могли бы попробовать поиграть с аннотациями — например, создать аннотацию, в которой указано разрешенное имя класса, но это зависит от обработки аннотаций.

Пример:

 @AllowedSubclasses(classnames="com.example.FooBar; *.AnyFooBar; com.example.foobars.*")
public abstract class Bar<F extends Foo<F>> {}
  

Затем обработчик аннотаций выдаст ошибку, если какой-либо другой класс подклассирует этот аннотированный класс.

Как насчет смешанного подхода: пометьте свои внутренние методы надписью «HANDS OFF» в javaDoc и документируйте, что любое нарушение приведет к исключениям во время выполнения. После вызова метода вы можете проверить внутри метода, является ли вызывающий объект экземпляром одного из классов, которым разрешено использовать эту функцию.

Ну, вместо того, чтобы полагаться на дженерики и т.д., Более простой способ добиться этого — обеспечить, чтобы вам нужен экземпляр Foo для создания Bar

 public Bar(Foo foo){...}
  

Таким образом, никто не сможет создать панель независимо от Foo . Это объединяет два класса и также указывает пользователям на этот факт. Есть и другие способы добиться этого … это всего лишь один пример

Вы можете создать makeBar конкретный метод, который вызывает a protected abstract makeBar0 , который выполняет фактическое создание. makeBar () может взять результат и проверить его на объекте любым удобным для вас способом.

 public abstract class Foo<F extends Foo<F>> {
    public Bar<F> makeBar() {
        Bar<F> bar = makeBar0();
        // check bar
        return bar;
    }
}
  

Если вы предпочитаете, вы могли бы добавить проверку создания Foo, что может повысить производительность. т.Е. проверьте возвращаемый тип makeBar0();