Comment puis-je faire de la méthode de retour de type générique?

Vous pouvez définir callFriend de cette façon:

public <T extends Animal> T callFriend(String name, Class<T> type) {
    return type.cast(friends.get(name));
}

Ensuite appeler comme tel:

jerry.callFriend("spike", Dog.class).bark();
jerry.callFriend("quacker", Duck.class).quack();

Ce code a l'avantage de ne pas générer des avertissements du compilateur. Bien sûr, cela est vraiment juste une version mise à jour de la conversion de la pré-générique de jours et de ne pas ajouter de sécurité supplémentaires.

Vous pourriez la mettre en œuvre comme ceci:

@SuppressWarnings("unchecked")
public <T extends Animal> T callFriend(String name) {
    return (T)friends.get(name);
}

(Oui, c'est légal, code; voir Java Génériques: type Générique défini comme type de retour seulement.)

Le type de retour sera déduit à partir de l'appelant. Toutefois, note le @SuppressWarnings annotation: qui vous dit que ce code n'est pas typesafe. Vous devez vérifier vous-même, ou vous pourriez obtenir ClassCastExceptions au moment de l'exécution.

Malheureusement, la façon dont vous l'utilisez (sans affecter la valeur de retour d'une variable temporaire), le seul moyen de faire le bonheur du compilateur est de l'appeler comme ceci:

jerry.<Dog>callFriend("spike").bark();

C'est peut-être un peu plus agréable que le casting, vous êtes probablement mieux de donner le Animal classe abstraite talk() méthode, comme David Schmitt dit.

En outre, vous pouvez demander à la méthode retourne la valeur dans un type donné de cette façon

<T> T methodName(Class<T> var);

Plus d'exemples ici à Oracle Java documentation

Comme vous l'avez dit en passant une classe serait OK, vous pouvez écrire ceci:

public <T extends Animal> T callFriend(String name, Class<T> clazz) {
   return (T) friends.get(name);
}

Et ensuite l'utiliser comme ceci:

jerry.callFriend("spike", Dog.class).bark();
jerry.callFriend("quacker", Duck.class).quack();

Pas parfait, mais c'est à peu près aussi loin que vous obtenez avec Java génériques. Il y a un moyen de mettre en œuvre Typesafe Hétérogène Conteneurs (THC) à l'aide de Super Jetons de Type, mais qui a ses propres problèmes à nouveau.

"Est-il un moyen de comprendre le type de retour à l'exécution sans le paramètre supplémentaire à l'aide de instanceof?"

Comme une solution alternative vous pourriez utiliser le modèle Visiteur comme ça. Faire des Animaux abstrait et faire mettre en œuvre Visitables:

abstract public class Animal implements Visitable {
  private Map<String,Animal> friends = new HashMap<String,Animal>();

  public void addFriend(String name, Animal animal){
      friends.put(name,animal);
  }

  public Animal callFriend(String name){
      return friends.get(name);
  }
}

Visitables signifie simplement qu'un Animal de la mise en œuvre est disposée à accepter un visiteur:

public interface Visitable {
    void accept(Visitor v);
}

Et un visiteur de la mise en œuvre est en mesure de visiter tous les sous-classes d'un animal:

public interface Visitor {
    void visit(Dog d);
    void visit(Duck d);
    void visit(Mouse m);
}

Ainsi, par exemple, un Chien de la mise en œuvre ressemblerait alors à ceci:

public class Dog extends Animal {
    public void bark() {}

    @Override
    public void accept(Visitor v) { v.visit(this); }
}

Le truc c'est que tant que le Chien sait quel type il est, il peut provoquer pertinentes surchargé visite méthode du visiteur v en passant "ce" en tant que paramètre. D'autres sous-classes en œuvre accept() exactement de la même manière.

La classe qui veut appeler la sous-classe des méthodes spécifiques doit alors mettre en œuvre le Visiteur interface comme ceci:

public class Example implements Visitor {

    public void main() {
        Mouse jerry = new Mouse();
        jerry.addFriend("spike", new Dog());
        jerry.addFriend("quacker", new Duck());

        //Used to be: ((Dog) jerry.callFriend("spike")).bark();
        jerry.callFriend("spike").accept(this);

        //Used to be: ((Duck) jerry.callFriend("quacker")).quack();
        jerry.callFriend("quacker").accept(this);
    }

    //This would fire on callFriend("spike").accept(this)
    @Override
    public void visit(Dog d) { d.bark(); }

    //This would fire on callFriend("quacker").accept(this)
    @Override
    public void visit(Duck d) { d.quack(); }

    @Override
    public void visit(Mouse m) { m.squeak(); }
}

Je sais que c'est beaucoup plus les interfaces et les méthodes que vous négocié, mais c'est une méthode standard pour obtenir une poignée sur chaque sous-type spécifique avec précisément zéro instanceof contrôles et zéro type de moulages. Et tout est fait dans un langage standard agnostique de la mode de sorte qu'il n'est pas juste pour Java, mais tout langage OO devrait fonctionner de la même.

J'ai écrit un article qui contient une preuve de concept, prise en charge de classes et une classe de test qui montre comment Super Jetons de Type peuvent être récupérées par vos cours au moment de l'exécution.
En un mot, il vous permet de déléguer à d'autres implémentations de la fonction réelle générique des paramètres transmis par l'appelant. Exemple:

• TimeSeries<Double> des délégués à l'intérieure privée de la classe qui utilise double[]
• TimeSeries<OHLC> des délégués à l'intérieure privée de la classe qui utilise ArrayList<OHLC>

Voir:
À l'aide de TypeTokens pour récupérer les paramètres génériques

Grâce

Richard Gomes - Blog

Pas vraiment, parce que comme vous le dites, le compilateur sait seulement que callFriend() retourne un Animal, pas un Chien ou d'un Canard.

Pouvez-vous ne pas ajouter un résumé makeNoise() la méthode de l'Animal qui sera mis en œuvre comme une écorce ou de charlatan par ses sous-classes?

Je sais que c'est une chose complètement différente que celle qui l'a demandé. Une autre façon de résoudre ce serait réflexion. Je veux dire, ce n'est pas à prendre au profit des Génériques, mais il permet de simuler, en quelque sorte, le comportement que vous souhaitez effectuer (faire un aboiement de chien, faire un duck quack, etc.) sans prendre soin de conversion de type:

import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
abstract class AnimalExample {
private Map<String,Class<?>> friends = new HashMap<String,Class<?>>();
private Map<String,Object> theFriends = new HashMap<String,Object>();
public void addFriend(String name, Object friend){
friends.put(name,friend.getClass());
theFriends.put(name, friend);
}
public void makeMyFriendSpeak(String name){
try {
friends.get(name).getMethod("speak").invoke(theFriends.get(name));
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
} 
public abstract void speak ();
};
class Dog extends Animal {
public void speak () {
System.out.println("woof!");
}
}
class Duck extends Animal {
public void speak () {
System.out.println("quack!");
}
}
class Cat extends Animal {
public void speak () {
System.out.println("miauu!");
}
}
public class AnimalExample {
public static void main (String [] args) {
Cat felix = new Cat ();
felix.addFriend("Spike", new Dog());
felix.addFriend("Donald", new Duck());
felix.makeMyFriendSpeak("Spike");
felix.makeMyFriendSpeak("Donald");
}
}

Je n'ai la suite dans ma lib kontraktor:

public class Actor<SELF extends Actor> {
public SELF self() { return (SELF)_self; }
}

sous-classement:

public class MyHttpAppSession extends Actor<MyHttpAppSession> {
...
}

au moins cela fonctionne à l'intérieur de la classe en cours et en ayant une forte référence typée. L'héritage Multiple fonctionne, mais devient vraiment difficile alors 🙂

public <X,Y> X nextRow(Y cursor) {
return (X) getRow(cursor);
}
private <T> Person getRow(T cursor) {
Cursor c = (Cursor) cursor;
Person s = null;
if (!c.moveToNext()) {
c.close();
} else {
String id = c.getString(c.getColumnIndex("id"));
String name = c.getString(c.getColumnIndex("name"));
s = new Person();
s.setId(id);
s.setName(name);
}
return s;
}

Vous pouvez retourner n'importe quel type et de recevoir directement comme. N'avez pas besoin de transtypage.

Person p = nextRow(cursor); //cursor is real database cursor.

C'est le mieux si vous souhaitez personnaliser n'importe quel autre type de dossiers au lieu d'un vrai curseurs.