inkompatible Typen beim Zurückgeben einer Klasse

Question

Ich verwende eine externe Bibliothek, über die ich keine Kontrolle habe. Es verlangt von mir, ein Verfahren zu implementieren, aber ich weiß nicht, wie die Art zurück, die erforderlich ist:

@Override 
public Optional<Class<? extends AnInterface<?>>> getCustomClass() { 
    return Optional.of(MyClass.class); 
    // compiler is giving error at the above line: 
    // error: incompatible types: inference variable T has incompatible bounds 
    // equality constraints: Class<? extends AnInterface<?>> 
    // lower bounds: Class<MyClass> 
    // where T is a type-variable: 
    // T extends Object declared in method <T>of(T) 
} 

MyClass:

public MyClass implements AnInterface<String> { 
    ... 
} 

ich dies auch versucht, aber es funktioniert nicht:

@Override 
public Optional<Class<? extends AnInterface<?>>> getCustomClass() { 
    Optional<Class<? extends AnInterface<?>> clazz = MyClass.class; 
    // this time the compiler gives error at the above line: 
    // error: incompatible types: Class<MyClass> cannot be converted to Class<? extends AnInterface<?>> 
    return clazz; 
} 

auch versucht, ein anderes, das funktioniert auch nicht:

@Override 
public Optional<Class<? extends AnInterface<?>>> getCustomClass() { 
    Optional<Class<? extends AnInterface> clazz = MyClass.class; 
    return clazz; 
    // this time the compiler gives error at the above line: 
    // error: incompatible types: inference variable T has incompatible bounds 
    // equality constraints: Class<? extends PropertyEditor<?>> 
    // lower bounds: Class<CAP#1> 
    // where T is a type-variable: 
    // T extends Object declared in method <T>of(T) 
    // where CAP#1 is a fresh type-variable: 
    // CAP#1 extends PropertyEditor from capture of ? extends PropertyEditor 
} 

Gibt es eine Idee, wie Sie die benutzerdefinierte Klasse zurückgeben?

JDK Version: 8u77

---

EDIT:

public abstract class ParentClass<T> { 
    public abstract T method(); 

    public class ImplementationClass implements ExternalLibraryInterface { 
     @Override 
     public Optional<Class<? extends AnotherExternalLibraryInterface<?>>> getCustomClass() { 
      return Optional.of(MyClass.class); 
      // compiler is giving error at the above line: 
      // error: incompatible types: inference variable T has incompatible bounds 
      // equality constraints: Class<? extends AnotherExternalLibraryInterface<?>> 
      // lower bounds: Class<MyClass> 
      // where T is a type-variable: 
      // T extends Object declared in method <T>of(T) 
     } 

     MyClass implements AnotherExternalLibraryInterface<String>{ 
      ... 
     } 
    } 
} 

Also aus irgendeinem Grund der Compiler durch die Wildcard verwechselt wird, wenn die überschriebene Methode der Umsetzung: Die Klassen sind wie folgt verschachtelt die externe Schnittstelle. Nach dem Verschieben aller Klassen in ihre eigenen Dateien funktioniert alles gut.

jedoch @ first-Lösung Zefick tatsächlich in der verschachtelten Klassen Situation funktioniert, werde ich es markieren, wie aufgelöst:

return (Optional)(Optional.of(MyClass.class)); 

Answer 1

Cast auf die rohen Optional Typ funktioniert, aber gibt eine Warnung aus.

public Optional<Class<? extends AnInterface<?>>> getCustomClass() { 
    return (Optional)(Optional.of(MyClass.class)); 
} 

Andere Lösung:

public Optional<Class<? extends AnInterface<?>>> getCustomClass() { 
    return Optional.<Class<? extends AnInterface<?>>>of(MyClass.class); 
}