メソッドの戻り値の型をジェネリックにする方法を教えてください。

次の例を考えてみてください（OOPブックでは一般的です）。

私にはAnimalクラスがあり、それぞれにAnimal多くの友達がいます。
好きなサブクラスDog、Duck、Mouseのような特定の動作を追加などbark()、quack()など

ここにAnimalクラスがあります：

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

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

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

そして、ここにたくさんの型キャストがあるコードスニペットがあります：

Mouse jerry = new Mouse();
jerry.addFriend("spike", new Dog());
jerry.addFriend("quacker", new Duck());

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

型キャストを取り除くために戻り値の型にジェネリックスを使用できる方法はありますか？

jerry.callFriend("spike").bark();
jerry.callFriend("quacker").quack();

以下に、使用されないパラメーターとしてメソッドに返される戻り値の型を含む初期コードをいくつか示します。

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

追加のパラメーターを使用せずに、実行時に戻りの型を理解する方法はありますinstanceofか？または、少なくともダミーのインスタンスの代わりにそのタイプのクラスを渡すことによって。
ジェネリックはコンパイル時の型チェック用であると理解していますが、これに対する回避策はありますか？

callFriendこのように定義できます：

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

次に、そのように呼び出します。

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

このコードには、コンパイラ警告を生成しないという利点があります。もちろん、これは実際には、前一般的な時代のキャストのアップデートバージョンであり、安全性を高めるものではありません。

いいえ。コンパイラはどのタイプjerry.callFriend("spike")が返されるかを知ることができません。また、実装では、型の安全性を追加することなく、メソッドのキャストを非表示にするだけです。このことを考慮：

jerry.addFriend("quaker", new Duck());
jerry.callFriend("quaker", /* unused */ new Dog()); // dies with illegal cast

この特定のケースでは、抽象talk()メソッドを作成し、サブクラスで適切にオーバーライドすることで、より適切に機能します。

Mouse jerry = new Mouse();
jerry.addFriend("spike", new Dog());
jerry.addFriend("quacker", new Duck());

jerry.callFriend("spike").talk();
jerry.callFriend("quacker").talk();

次のように実装できます。

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

（はい、これは正当なコードです。JavaGenerics：戻り値の型としてのみ定義された汎用型を参照してください。）

戻り値の型は呼び出し元から推測されます。ただし、@SuppressWarnings注釈に注意してください。このコードはタイプセーフではないことを示しています。自分で確認する必要がありClassCastExceptionsます。確認しないと、実行時に取得できます。

残念ながら、（一時的な変数に戻り値を割り当てずに）それを使用する方法は、コンパイラーを満足させる唯一の方法は、次のように呼び出すことです。

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

これはキャストより少し良いかもしれませんが、David Schmittが言ったように、Animalクラスに抽象talk()メソッドを与える方が良いでしょう。

この質問は、Effective Javaのアイテム29「タイプセーフな異種コンテナを検討する」とよく似ています。ラズの答えはブロッホの解決策に最も近いものです。ただし、安全のため、putとgetの両方でクラスリテラルを使用する必要があります。署名は次のようになります。

public <T extends Animal> void addFriend(String name, Class<T> type, T animal);
public <T extends Animal> T callFriend(String name, Class<T> type);

両方のメソッド内で、パラメーターが正常であることを確認する必要があります。詳細については、Effective JavaとClass javadocを参照してください。

さらに、この方法で特定の型の値を返すようにメソッドに要求できます

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

より多くの例ここで OracleのJavaドキュメントで

これはより簡単なバージョンです：

public <T> T callFriend(String name) {
    return (T) friends.get(name); //Casting to T not needed in this case but its a good practice to do
}

完全に機能するコード：

    public class Test {
        public static class Animal {
            private Map<String,Animal> friends = new HashMap<>();

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

            public <T> T callFriend(String name){
                return (T) friends.get(name);
            }
        }

        public static class Dog extends Animal {

            public void bark() {
                System.out.println("i am dog");
            }
        }

        public static class Duck extends Animal {

            public void quack() {
                System.out.println("i am duck");
            }
        }

        public static void main(String [] args) {
            Animal animals = new Animal();
            animals.addFriend("dog", new Dog());
            animals.addFriend("duck", new Duck());

            Dog dog = animals.callFriend("dog");
            dog.bark();

            Duck duck = animals.callFriend("duck");
            duck.quack();

        }
    }

クラスを渡すのは問題ないと言ったので、次のように書くことができます。

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

そして、次のように使用します。

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

完璧ではありませんが、これはJavaジェネリックを使用する場合に限ります。Super Type Tokenを使用してTypesafe Heterogenous Containers（THC）を実装する方法はありますが、これにも固有の問題があります。

スーパータイプトークンと同じアイデアに基づいて、文字列の代わりに使用する型付きIDを作成できます。

public abstract class TypedID<T extends Animal> {
  public final Type type;
  public final String id;

  protected TypedID(String id) {
    this.id = id;
    Type superclass = getClass().getGenericSuperclass();
    if (superclass instanceof Class) {
      throw new RuntimeException("Missing type parameter.");
    }
    this.type = ((ParameterizedType) superclass).getActualTypeArguments()[0];
  }
}

しかし、これは目的を無効にする可能性があると思います。各文字列に対して新しいidオブジェクトを作成して保持する必要があるためです（または正しいタイプ情報で再構築する必要があります）。

Mouse jerry = new Mouse();
TypedID<Dog> spike = new TypedID<Dog>("spike") {};
TypedID<Duck> quacker = new TypedID<Duck>("quacker") {};

jerry.addFriend(spike, new Dog());
jerry.addFriend(quacker, new Duck());

ただし、キャストを行わなくても、本来の方法でクラスを使用できます。

jerry.callFriend(spike).bark();
jerry.callFriend(quacker).quack();

これは、ID内のタイプパラメータを非表示にするだけですが、必要に応じて、後で識別子からタイプを取得できることを意味します。

IDの2つの同一のインスタンスを比較できるようにする場合は、TypedIDの比較およびハッシュメソッドも実装する必要があります。

「instanceofを使用して、追加のパラメーターなしで実行時に戻り値の型を把握する方法はありますか？」

代替ソリューションとして、次のようなVisitorパターンを利用できます。動物を抽象化し、Visitableを実装します。

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);
  }
}

訪問可能とは、Animalの実装が訪問者を受け入れる用意があることを意味します。

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

そしてビジターの実装は動物のすべてのサブクラスを訪問することができます：

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

したがって、たとえば、犬の実装は次のようになります。

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

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

ここでのトリックは、Dogがどのタイプかを知っているので、「this」をパラメーターとして渡すことで、訪問者vの関連するオーバーロードされた訪問メソッドをトリガーできることです。他のサブクラスもまったく同じ方法でaccept（）を実装します。

次に、サブクラス固有のメソッドを呼び出すクラスは、次のようにVisitorインターフェースを実装する必要があります。

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(); }
}

あなたが交渉したよりもはるかに多くのインターフェイスとメソッドであることは知っていますが、インスタンスのチェックと型キャストがまったくゼロである特定のサブタイプごとにハンドルを取得する標準的な方法です。そして、それはすべて標準言語にとらわれない方法で行われるので、それはJavaだけでなく、あらゆるOO言語が同じように機能するはずです。

ありえない。文字列キーのみが与えられた場合、マップはどのようにして、Animalのどのサブクラスを取得するかを知っているはずですか？

これが可能になる唯一の方法は、各Animalが1種類の友達しか受け入れなかった場合（その後、Animalクラスのパラメーターである可能性があります）、またはcallFriend（）メソッドが型パラメーターを取得した場合です。しかし、継承のポイントが欠けているように見えます。つまり、スーパークラスのメソッドのみを使用する場合は、サブクラスを均一にしか処理できないということです。

概念実証、サポートクラス、および実行時にスーパータイプトークンをクラスが取得する方法を示すテストクラスを含む記事を書きました。簡単に言うと、呼び出し元から渡された実際の汎用パラメーターに応じて、代替実装に委任できます。例：

• TimeSeries<Double> を使用するプライベート内部クラスにデリゲート double[]
• TimeSeries<OHLC> を使用するプライベート内部クラスにデリゲート ArrayList<OHLC>

参照： TypeTokensを使用してジェネリックパラメーターを取得する

ありがとう

リチャードゴメス- ブログ

ここには多くの素晴らしい答えがありますが、これは私がAppiumテストで採用したアプローチであり、単一の要素に作用すると、ユーザーの設定に基づいてさまざまなアプリケーション状態に移行する可能性があります。OPの例の慣例には従いませんが、誰かを助けることを願っています。

public <T extends MobilePage> T tapSignInButton(Class<T> type) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    //signInButton.click();
    return type.getConstructor(AppiumDriver.class).newInstance(appiumDriver);
}

• MobilePageは、タイプが拡張するスーパークラスであり、その子を使用できることを意味します（duh）
• type.getConstructor（Param.classなど）を使用すると、型のコンストラクターを操作できます。このコンストラクタは、予想されるすべてのクラスで同じである必要があります。
• newInstanceは、新しいオブジェクトのコンストラクタに渡す宣言された変数を受け取ります

エラーをスローしたくない場合は、次のようにしてエラーをキャッチできます。

public <T extends MobilePage> T tapSignInButton(Class<T> type) {
    // signInButton.click();
    T returnValue = null;
    try {
       returnValue = type.getConstructor(AppiumDriver.class).newInstance(appiumDriver);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return returnValue;
}

あなたが言うように、コンパイラは、callFriend（）がDogまたはDuckではなく、Animalを返すことだけを知っているので、実際にはそうではありません。

サブクラスによって樹皮またはいんちきとして実装されるであろう、抽象的なmakeNoise（）メソッドをAnimalに追加できませんか？

ここで探しているのは抽象化です。インターフェイスに対するコードを増やすと、キャストを少なくする必要があります。

以下の例はC＃で記述されていますが、概念は同じです。

using System;
using System.Collections.Generic;
using System.Reflection;

namespace GenericsTest
{
class MainClass
{
    public static void Main (string[] args)
    {
        _HasFriends jerry = new Mouse();
        jerry.AddFriend("spike", new Dog());
        jerry.AddFriend("quacker", new Duck());

        jerry.CallFriend<_Animal>("spike").Speak();
        jerry.CallFriend<_Animal>("quacker").Speak();
    }
}

interface _HasFriends
{
    void AddFriend(string name, _Animal animal);

    T CallFriend<T>(string name) where T : _Animal;
}

interface _Animal
{
    void Speak();
}

abstract class AnimalBase : _Animal, _HasFriends
{
    private Dictionary<string, _Animal> friends = new Dictionary<string, _Animal>();


    public abstract void Speak();

    public void AddFriend(string name, _Animal animal)
    {
        friends.Add(name, animal);
    }   

    public T CallFriend<T>(string name) where T : _Animal
    {
        return (T) friends[name];
    }
}

class Mouse : AnimalBase
{
    public override void Speak() { Squeek(); }

    private void Squeek()
    {
        Console.WriteLine ("Squeek! Squeek!");
    }
}

class Dog : AnimalBase
{
    public override void Speak() { Bark(); }

    private void Bark()
    {
        Console.WriteLine ("Woof!");
    }
}

class Duck : AnimalBase
{
    public override void Speak() { Quack(); }

    private void Quack()
    {
        Console.WriteLine ("Quack! Quack!");
    }
}
}

私のlib kontraktorで次のことを行いました：

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

サブクラス化：

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

少なくとも、これは現在のクラス内で機能し、強い型付き参照がある場合に機能します。多重継承は機能しますが、そのとき本当にトリッキーになります:)

これはまったく違うことだと私は聞いた。これを解決する別の方法は、リフレクションです。つまり、これはGenericsの利点を活用していませんが、型キャストを気にせずに、実行したい動作（犬の鳴き声、カモの鳴き声など）をエミュレートできます。

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");

    }

}

どうですか

public class Animal {
private Map<String,<T extends Animal>> friends = new HashMap<String,<T extends Animal>>();

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

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

}

別のアプローチがあります。メソッドをオーバーライドするときに戻り値の型を絞り込むことができます。各サブクラスでは、そのサブクラスを返すためにcallFriendをオーバーライドする必要があります。コストはcallFriendの複数の宣言になりますが、内部で呼び出されるメソッドに共通の部分を分離できます。これは、上記の解決策よりもはるかに単純で、戻り値の型を決定するための追加の引数は必要ありません。

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;
}

どんなタイプでも返して直接受け取ることができます。型キャストする必要はありません。

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

これは、実際のカーソルではなく他の種類のレコードをカスタマイズする場合に最適です。