Если следующий код компилируется под Java 1.8

Ответ 1

Насколько я понимаю, этот код должен компилироваться, но, конечно, не без непроверенного предупреждения.

Вы указали переменную service необработанного типа AbstractService, которая является подтипом необработанного типа service, который имеет метод void service(Base), который является стиранием void service(T).

Таким образом, вызов service.service(base) может вызывать этот метод void service(Base), объявленный в service, конечно, с непроверенным предупреждением, поскольку метод является общим и не проверяет параметр типа T.

Это может быть противоречивым, поскольку тип AbstractService переопределяет этот метод с методом, стирание которого void service(Derived), но этот метод может переопределять другой метод в общем контексте, а не в отношении отношения типа исходного типа.

Или, другими словами, тип can not переопределяет метод таким образом, что он более ограничивает типы параметров, чем переопределенный метод супертипа.

Это также относится к наследованию общего типа, но к другому результату. Если ваша переменная имела тип AbstractService<X>, то X должен быть назначен Derived из-за ограничения параметра типа. Этот тип AbstractService<X> является подтипом Service<X>, который имеет метод void service(X) (as T: = X), который переопределяется (реализуется) AbstractService<X> с помощью метода void service(X), который принимает тот же типы аргументов.

Так как на вашем сайте существует некоторая путаница, я хочу подчеркнуть, что это не имеет никакого отношения к вашему оператору if(… instanceof Derived). Как объяснялось выше, это поведение связано с использованием типа raw, что означает, что вы используете AbstractService без фактического аргумента типа и в основном отключите проверку типа Generics. Это будет даже работать, если вы написали

public void bar(Base base) {
    service.service(base); // UNCHECKED invocation
}

Если вы изменили объявление переменной на

private AbstractService<Derived> service;

он больше не будет сырым типом, и проверка типа произойдет, а service.service(base) создаст ошибку компилятора, независимо от того, заключите ли вы ее с помощью if(base instanceof Derived) { … } или нет.

Существуют только типы сырья для совместимости только с кодом Pre-Generics, и вы должны избегать их использования и не игнорировать предупреждения, вызванные использованием типа raw.

Ответ 2

Это, конечно, о типах

Как говорили другие, вам нужно отбросить базу до Derived, чтобы она удовлетворяла требованиям к сервису (значение T), поскольку компилятор знает, что этот аргумент для AbstractService.service должен расширять Derived, и поэтому, если он не является производным, он не может соответствовать.

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

Из-за определения AbstractService, service на самом деле AbstractService<? extends Derived>, и если вы устраните это упущение, вы просто получите сообщение об ошибке.

Это связано с тем, что AbstractService<? extends Derived> не расширяет AbstractService<Derived>, а база casting до Derived исправляет проблему для AbstractService<Derived>.

Посмотрите на классы ниже, чтобы увидеть пример этого. ConcreteService не расширяется AbstractService<Derived>, он расширяет AbstractService<RealDerived>. Вы не можете передать только Derived в ConcreteService.service(RealDerived base), например, вы не можете передать объект FalseDerived, потому что это не удовлетворяет типу аргумента.

Истина заключается в том, что где-то что-то должно действительно определять, что такое T, чтобы мы могли исправить проблему безопасности типа.

Выполнение этого в общем случае требует некоторого обмана, такого как класс, который связывает фактический тип аргумента с фактическим типом службы, так что кастинг может выполняться с помощью вида typeafe.

Как следует

public class FooTest {

    public static class Base {
    }

    public static class Derived extends Base {
    }

    public interface Service<T extends Base> {
        void service(T value);

    }    

    public abstract static class AbstractService<T extends Derived> implements  Service<T> {

        public void service(T value) {
        }

    }

    // The following class defines an argument B that and ties together the type of the service with the type of the referenced stored class which enables casting using the class object 
    public abstract static class Barrer<B extends Derived>{

        private AbstractService<B> service;

        private Class<B> handledClass;


        protected Barrer(Class<B> handledClass, AbstractService<B> service){
            this.handledClass = handledClass;
            this.service = service;
        }

        public  void bar(Base base) {
            if(handledClass.isAssignableFrom(base.getClass())) {
                service.service(handledClass.cast(base)); // compile error at this line
            }
        }

    }

// the following classes provide concrete implementations and the concrete class to perform the casting.   

    public static class RealDerived extends Derived{}

    public static class FalseDerived extends Derived{}

    public static class ConcreteService extends AbstractService<RealDerived>{
    }


    public static class ConcreteBarrer extends Barrer<RealDerived> {
        protected ConcreteBarrer() {
            super(RealDerived.class,new ConcreteService());
        }

    }
}