Consider this Generics Code:
interface Collection<E> {
public void add (E x);
public Iterator<E> iterator();
}
And this one:
public class MyClass<V> {
V v;
setSomeValue(V val) {
v=val;
}
V getSomeValue() {
return v;
}
}
My Question:
Do those letters in angular brackets:
<V> and <E>
have specific meaning.
Can i use any English Alphabet. i.e can they be
<A> or <Q>?
They do have to be valid Java identifiers (not necessarily just single letters as pointed out in the comment,) technically you can use any identifier that you like and your code will compile and run fine (if there are no other errors of course!)
It's good to stick to convention though - this tends to be single capital letters. Some common ones are E, T, K and V, standing for element, type, key and value respectively - your use case may well fit into one of those categories, in which case I'd use those letters. In the case of the above example, the Collection class uses E because it contains elements.
interface Collection<E> {
public void add (E x);
public Iterator<E> iterator();
}
Defining an interface like this means that you are telling compiler that, you can create a reference of this interface of any type... But, you have to use just letters to indicate generic type..
Ideally it is not a constraint that you should use only T, E, or V.. You can use any of them.. But, your code is more readable if you follow certain conventions..
K - Key, V - Value.. Like this..
So, the references for your above interface can be: -
Collection<String>, Collection<Integer>, Collection<YourCustomObject>
And whatever type you use, that will automatically get reflected in your method return types and parameters..
So, for Collection<String>, your method would look like this: -]
public void add (String x);
public Iterator<String> iterator();
Usually they do but the compiler let's you name them as you want; as any other type since it represents a generic name for a type.
The convention is:
T - type; most used in custom classes
E - element; used in collection
K - key; used in map
V - value; used in map
Those E or V or whatever are just variables. They just suggest that the type is unknown at the time of writing the code. This also simplifies the job by using the same class for so many types of objects.
These can be understood from http://docs.oracle.com/javase/tutorial/java/generics/index.html
The most commonly used type parameter names are:
E - Element (used extensively by the Java Collections Framework)
K - Key
N - Number
T - Type
V - Value
S,U,V etc. - 2nd, 3rd, 4th types
They are else can be defined as wildcards in java. These generics are mostly used to make a single class which is applicable for many types without requiring casting.
I think they have to be letters. They are basically placeholders for class names. So if you wanted to instantiate MyClass you could do
new MyClass<String>();
This will replace all V in your code with String.
This lesson has more details on generics
To quote this lesson
The most commonly used type parameter names are:
E - Element (used extensively by the Java Collections Framework)
K - Key
N - Number
T - Type
V - Value
S,U,V etc. - 2nd, 3rd, 4th types
The E, V etc. are type parameters. They do not have to be single, upper-case letters - you can use anything that's a valid identifier in Java.
Almost everybody uses single upper-case letters for type parameters - it's a convention that almost everybody follows, so I strongly suggest you do the same.
You could for example just as well do:
public class MyClass<Value> {
Value v;
setSomeValue(Value val) {
v=val;
}
Value getSomeValue() {
return v;
}
}
return valueandvalue = val