Forcer un appel non contrôlé

Question

Parfois, lorsque vous utilisez une réflexion Java ou une opération de stockage spéciale dans Object, vous obtenez des avertissements non contrôlés. Je me suis habitué et quand je ne peux rien y faire, je documente pourquoi un appel n'est pas contrôlé et pourquoi il devrait être considéré comme sûr.

Mais, pour la première fois, j'ai une erreur sur un appel non contrôlé. Cette fonction:

public <K,V extends SomeClass & SomeOtherClass<K>> void doSomethingWithSomeMap (Map<K,V> map, V data); 

Je pense que l'appelant ainsi:

Map someMap = ...; 
SomeClass someData = ...; 
doSomethingWithSomeMap(someMap, someData); 

me donnerait un avertissement d'appel sans contrôle. Jikes fait un avertissement, mais javac me donne une erreur:

Error: <K,V>doSomethingWithSomeMap(java.util.Map<K,V>,V) in SomeClass cannot be applied to (java.util.Map,SomeClass)

Une manière de le forcer à compiler avec un avertissement?

Merci.

Answer 1

Vous savez déjà que le problème est le type de someData. Malheureusement, Java ne vous permet pas actuellement d'utiliser le type d'intersection SomeClass & SomeOtherClass comme type pour déclarer une variable, ni comme cible de chat.

Mais il y a une façon pas si parfaite de faire exactement cela, en introduisant une variable de type parasite X extends SomeClass & SomeOtherClass, puis en déclarant X someData.

Cela devrait être fait sur la méthode qui produit des valeurs pensivement à affecter à someData. Un casting non contrôlé (X) sera nécessaire, ce qui est prouvé sûr.

Dans l'ensemble, quelque chose comme ceci:

public <X extends SomeClass & SomeOtherClass> 
void doReflectionMagic() { 
    Map someMap = ...; 
    X someData = (X) ...; 
    doSomethingWithSomeMap(someMap, someData); 
} 

Answer 2

Essayez de le préciser explicitement:

//Type2 is subclass of (or implements) SomeClass 
Map<Type1, Type2> someMap = ...; 
SomeClass someData = ...; 
<Type1, Type2>doSomethingWithSomeMap(someMap, someData); 

Answer 3

Vous spécifiez la seconde borne V pour étendre SomeOtherClass. Mais je suppose que SomeClass n'implémente pas SomeOtherClass (si c'était le cas, vous n'auriez pas besoin de plusieurs bornes). Donc, certaines données ne sont pas conformes à cette limite, et donc l'erreur du compilateur. La variable someData doit appartenir à une classe qui à la fois étend SomeClass et implémente SomeOtherClass.

Answer 4

Dans quel vaudou avez-vous vous-même :)? De la question et des commentaires, j'ai supposé que vous êtes sûr que vous avez des objets qui étendent la classe abstraite SomeClass et implémentent également l'interface SomeOtherClass. Si c'est le cas, je suggère une classe abstraite intermédiaire dans la hiérarchie qui partage ces propriétés.

public abstract class Foo<K> extends SomeClass implements SomeOtherClass<K> { 
    ... 
} 

De cette façon, vous pouvez simplifier la signature de la méthode statique:

public <K,V extends Foo<K>> void doSomethingWithSomeMap (Map<K,V> map, V data); 

Si vous ne voulez pas changer votre hiérarchie d'objets courant, vous pouvez tromper le compilateur en utilisant un autre niveau d'indirection avec le adapter pattern.

« Tous les problèmes en informatique peuvent être résolus par un autre niveau de indirection. » - David Wheeler

public abstract class SomeClass {  
    public abstract void method1(); 
} 

public interface SomeOtherClass<K> { 
    void method2(K value); 
} 

public class MyClass extends SomeClass implements SomeOtherClass<Integer> { 
    @Override 
    public void method1() { 
    System.out.println("MyClass.method1"); 
    } 

    @Override 
    public void method2(Integer value) { 
    System.out.println("MyClass.method2(" + value + ")"); 
    } 
} 

public class Indirection<K> extends SomeClass implements SomeOtherClass<K> { 
    private final Object objectValue; 

    public Indirection(final Object value) { 
    this.objectValue = value; 
    } 

    @Override 
    public void method1() { 
    ((SomeClass) objectValue).method1(); 
    } 

    @Override 
    public void method2(K value) { 
    @SuppressWarnings("unchecked") 
    SomeOtherClass<K> delegate = ((SomeOtherClass<K>) objectValue); 

    delegate.method2(value); 
    } 
} 

public static void main(String[] args) { 
    Map someMap = new HashMap<Integer, MyClass>(); 
    SomeClass someData = new MyClass(); 
    Indirection a = new Indirection(someData); 
    doSomethingWithSomeMap(someMap, a, 12); 
} 

public static <K,V extends SomeClass & SomeOtherClass<K>> 
void doSomethingWithSomeMap (Map<K,V> map, V data, K value) { 
    data.method1(); 
    data.method2(value); 
} 

Ce imprimerait:

MyClass.method1
MyClass.method2 (12)