ジェネリック医薬品、例えば型消去および静的ファブリック方法

Question

は、私がSimpleCallbackクラスに

public class SimpleCallback<T> implements Callback<T> { 

    private SuccessListener<T> successListener; 
    private ErrorListener errorListener; 

    protected SimpleCallback() { 

    } 

    public static <C> SimpleCallback<C> success(SuccessListener<C> listener) { 
     SimpleCallback<C> callback = new SimpleCallback<>(); 
     callback.successListener = listener; 
     return callback; 
    } 

    public SimpleCallback<T> error(ErrorListener errorListener) { 
     this.errorListener = errorListener; 
     return this; 
    } 

    @Override 
    public void onComplete(T result) { 
     notifySuccess(result); 
    } 

    @Override 
    public void onError() { 
     notifyError(); 
    } 

    public interface SuccessListener<T> { 

     void onSuccess(T result); 
    } 

    public interface ErrorListener { 

     void onError(); 
    } 

} 

を持っている今、私は猫が非同期取得のためにこのコールバックを使用したい：

SimpleCallback<List<Cat>> callback = SimpleCallback 
      .success(cats -> cats.forEach(Cat::meow)); 

今は大丈夫ですが、とき私は私の猫は

SimpleCallback<List<Cat>> callback = SimpleCallback 
      .success(cats -> cats.forEach(Cat::meow)) <-- Here cats become objects 
      .error(() -> System.out.println("Cats error")); 

一つの解決策の使用明示的なジェネリックTYの生の対象となるエラーリスナーを追加したいですpe：

SimpleCallback<List<Cat>> callback = SimpleCallback.<List<Cat>> 
      .success(cats -> cats.forEach(Cat::meow)) 
      .error(() -> System.out.println("Cats error")); 

しかし、少し醜いです。明示的なジェネリック型なしでコールバックを作成する方法はありますか？

UPD：私は@Jesperが

別の解決策が明示的にラムダ式の引数の型を提供することで優れたソリューションを提供すると思う：ジェネリック型変数を消去する

.success((List<Cat> cats) -> cats.forEach(Cat::meow)) 

Answer 1

明らかに戦略を文脈に沿って変化する。 確かにこの仕組みがどういうルールでなければなりませんが、私はそれらを知らないのです。残念です。実用的な観点から、Jesperによって提案された解決策、すなわち、成功方法において型情報を与えることは、私にとって完全に受け入れられるように思える。

.success((List<Cat> cats) -> cats.forEach(Cat::meow))

それ以外の場合は、単一の方法で、両方のリスナーを通過することが可能である：

public static <C> SimpleCallback<C> create(
    SuccessListener<C> successListener, ErrorListener errorListener) { 
    SimpleCallback<C> callback = new SimpleCallback<>(); 
    callback.successListener = successListener; 
    callback.errorListener = errorListener; 

    return callback; 
} 

と単一工程でコールバックを作成する：いいえ、要するに

Callback<List<Cat>> callback = SimpleCallback 
     .create(
      cats -> cats.forEach(Cat::meow), 
      () -> System.out.println("Cats error") 
     ); 

Answer 2

。 this answer about how the diamond operator functions in Java 1.8から、連鎖したメソッド呼び出しには型推論の問題があります。

SimpleCallback<List<Cat>> callback = SimpleCallback 
     .success(cats -> cats.forEach(Cat::meow)); 

がsuccessに与えられた引数からタイプCを推測されているため、あなたの例では、類似しています。

したがって、あなたのオプションは次のとおりです。

• 明示的に私は、ジェネリック型
• があなた例えばチェーン通話

を使用する前に、（明示的に宣言ジェネリック型を持つ）という名前の参照を取得します宣言します

パブリッククラスSimpleCallback implementsコールバック{

private SuccessListener<T> successListener; 
private ErrorListener errorListener; 

protected SimpleCallback() { 

} 

public static <C> SimpleCallback<C> create() { 
    return new SimpleCallback<>(); 
} 

public SimpleCallback<T> withSuccessListener(SuccessListener<T> listener) { 
    this.successListener = listener; 
    return this; 
} 

public SimpleCallback<T> withErrorListener(ErrorListener errorListener) { 
    this.errorListener = errorListener; 
    return this; 
} 

@Override 
public void onComplete(T result) { 
    notifySuccess(result); 
} 

@Override 
public void onError() { 
    notifyError(); 
} 

public interface SuccessListener<T> { 

    void onSuccess(T result); 
} 

public interface ErrorListener { 

    void onError(); 
} 

}

し、次いで、追加および次に連鎖、一列に作成します。

SimpleCallback<List<Cat>> callback = SimpleCallback.create(); 
callback = callback.success(cats -> cats.forEach(Cat::meow)) 
        .error(() -> System.out.println("Cats error"));