ArrayList<? extends A> means an ArrayList of some unknown type that extends A. That type might not be C, so you can’t add a C to the ArrayList. In fact, since you don’t know what the ArrayList is supposed to contain, you can’t add anything to the ArrayList. If you want an ArrayList that can … Read more
I am just going to answer the differences between declaration-site and use-site variance, since, while C# and Java generics differ in many other ways, those differences are mostly orthogonal to variance. First off, if I remember correctly use-site variance is strictly more powerful than declaration-site variance (although at the cost of concision), or at least … Read more
If the return type must be the type of the class that implements the interface, then what you want is called an F-bounded type: public interface A<T extends A<T>>{ public T b(); } public class C implements A<C>{ public C b() { … } } public class D implements A<D>{ public D b() { … … Read more
Your problem is a side-effect of Generalized Target-type Inference, an improvement in Java 8. What is Target-type Inference Let’s take your example method, public static <R> R get(String d) { return (R)d; } Now, in the method above, the generic parameter R cannot be resolved by the compiler because there’s no parameter with R. So, … Read more
You can’t do this in general because of type erasure – an instance of A<String> doesn’t know the type of T. If you need it, one way is to use a type literal: public class A<T> { private final Class<T> clazz; public A<T>(Class<T> clazz) { this.clazz = clazz; } // Use clazz in here } … Read more
Bizarre behavior here… VS2k8 console app. The following: try { throw new T(); } catch (T tex) { Console.WriteLine(“Caught passed in exception type”); } catch (Exception ex) { Console.WriteLine(“Caught general exception”); } results in “Caught general exception”. But, remove the (useless) variables from the catch statements: try { throw new T(); } catch (T) { … Read more
While the type parameters of a generic method can be restricted by bounds, such as extends Foo & Bar, they are ultimately decided by the caller. When you call getFooBar(), the call site already knows what T is being resolved to. Often, these type parameters will be inferred by the compiler, which is why you … Read more
This declares the readObjectData method generic, with one type parameter, T. public <T> … Then the return type is T. … T readObjectData(… Without the initial <T>, which is the generic type declaration, the symbol T will be undefined. In the parameter list, Class<T> type is one of the parameters. Because the return type and … Read more
Since the actual type T is available to you only through reflection, you would need to access methods of Store<T> through reflection as well: Type constructedType = classType.MakeGenericType(typeParams); object x = Activator.CreateInstance(constructedType, new object[] { someParameter }); var method = constructedType.GetMethod(“MyMethodTakingT”); var res = method.Invoke(x, new object[] {someObjectThatImplementsStorable}); EDIT You could also define an additional … Read more
EDIT : Starting from Mockito 1.10.x, generics types that are embedded in the class are now used by Mockito for deep stubs. ie. public interface A<T extends Observer & Comparable<? super T>> { List<? extends B> bList(); T observer(); } B b = deep_stubbed.bList().iterator().next(); // returns a mock of B ; mockito remebers that A … Read more