Introduction -

Arrays are always safe wrt type. for example_ if our our program requirement is to add only String objects then we can go for String[] array. for this array we can add only String type of objects, if we are try to add any other type then we will get compiler time error.

String s = new String[111];

s[0] = "arjava";

s[1] = new Student(); // error: inCompaitable types found Student required String

Hence, in the case of arrays we can give the guarantee about the type of elements. String[] array contains only string objects, so arrays are always safe to use.

But, Collection is not safe to use wrt type, for example_ if our program requirement is to hold only String objects and if we use ArrayList, by mistake if we are trying to add any other type to the list then we won't get any compile time error but program may fail at run time.

ArrayList al = new ArayList();

al.add("arjava");

al.add(new Student());

String s1 = (String)al.get(0);

String s2 = (String)al.get(1); // error: RE classCastException

There is no guarantee that collection can hold a particular type of object, hence wrt type collection are not safe to use.

In the case of Arrays at the time of retrieval there is no required to perform TypeCasting, but in collection compulsory we have to provide TypeCasting otherwise we will get compile time error. to overcome of this collection problem (Type Safe and TypeCasting) generics concept is introduced.

The main objective of Generics concept -

• To provide type safety to the collection, so that they can hold only particular type of objects.
• To resolve Type Casting problem, for example_ To hold only String type of objects a generic of arraylist can be declare as
• ArrayList <String> al = new ArrayList<String>(); // Here <String> is parameter type

Usage of parent class reference to hold child class object is considered as polymorphism, polymorphism concept is allowed only for base type not for parameter type. for parameter we can use only class name or interface name.

Generic Classes

Until 1.4 version a non generic version of ArrayList class used to declare as follows -

class ArrayList {

add(object o);

Object get(int index)

}

• The argument to add() method is object, so we can add any type of object. we are not getting Type Safety
• The return type of get() method is object, hence at the time of return compulsory we have to perform Type Casting.

In 1.5 version a generic version of ArrayList class use to declare as follows -

class ArrayList<T> {

add<T t>

T get(int index)

}

based on our requirement Type parameter 'T' will be replace with corresponding provided type. for example_ To hold only String type of object we have to create generic version of ArrayList object as follows.

ArrayList<String> al = new ArrayList();

we can pass any number of parameter, through generic we are associating a type parameter to the classes, such type of parameterized classes are called generic class.

Bounded Types

• We can bound the type parameter for a particualar range by using extends keyword
• As the parameter we can pass either numbers type or it's child classes, it is bounded type

Test<Integer> t1 = new Test<Integer>();

Test<String> t2 = new Test<String>(); // compile time error

we can bound the parameter in combination also

class Test<T extends Numbers & Runnable>

as the type parameter we can pass any type which is the child class of numbers and implements runnable interface

Generic Methods

m1(ArrayList<String> al)

• This method is applicable for ArrayList<String> (ArrayList of any string type)
• Within the method we can add String type objects & null to the list if we are trying to add any other type we will get compile time error

m2(ArrayList<? extends x> al)

• We can call this method by passing ArrayList of any type, but within the method we can't add any other type except null to the list, because we don't know the type exactly

m3(AL <? extends x> l)

• If x is a class then we can call this method by passing ArrayList of either x type or its child classes.
• If x is an interface then we can call this method by passing ArrayList of either x type or it's implementation class.
• Here also, we can't add any other type of elements to the list except null.

m4(ArrayList <? super x> l)

• If x is a class then this method is applicable for ArrayList of either x type or it's super class.
• If x is an interface then this method is applicable for ArrayList of either x type or super classes of implementation class of x
• Within the method we can add only x type objects and null to the list.

Note: we can define the parameter either at class level or at method level

Conclusion

• Generic concept is applicable only at compile time to provide type safety and to resolve type casting problems, at runtime there is no such type of concept. so the following declarations are equal -

AL l = new AL();

AL l = new AL<String>();

AL l = new AL<interface>();

ArrayList l = new ArrayList<String>();

l.add("a");

l.add("10");

l.add("true");

System.out.println(l); //output - [a, 10, true]

These two declarations are equal

AL<String> l = new AL<String>();

AL<String> l = new AL();