Generics allow you to create a type-safe way of storing a 'generic' class type ( and thanks to autoboxing primitive types aswell ).
On methods, you can define template parameters in the following way:
< Template_Paramter, TemplateParam2 > returnType methodName( arguments ... ) { }
The template parameters can now be used anywhere in that method ( including the arguments and return type ) as normal class type 'types'.
To see an application of this, consider the following method that returns the third element of (almost) any array type:
void main(){ String[] s = { "hi", "how", "are", "you" }; String third = getElement3( s ); println( third ); } < T > T getElement3( T[] array ){ return array[2]; }
I say almost any array type because this won't work on arrays of primitive types, but if you create an array of Integer (or the other class-type equivalent) then you can get the same effect:
void main(){ Integer[] ints = { 1,2,3,4,5}; int third = getElement3( ints ); println( third ); } < T > T getElement3( T[] array ){ return array[2]; }
Template parameters can also be used in classes, below is a class which stores a pair of Type-Parameterd objects:
class Pair<T>{ T a; T b; }
To create an instance of this class, we must say what the type-parameters are bound to. Note, in Kenya if you use a primitive type as the binding type, it is internally automatically converted up to the class type for you; i.e.:
void main() { Pair<String> twoStrings; twoStrings.a = "hello"; twoStrings.b = "world"; //This is equivalent to Pair<Integer> Pair<int> twoInts; twoInts.a = 3; twoInts.b = 4; } class Pair<T>{ T a; T b; }