Generics in Java

Generics in Java is similar to templates in C++. The idea is to allow type (Integer, String, … etc and user defined types) to be a parameter to methods, classes and interfaces. For example, classes like HashSet, ArrayList, HashMap, etc use generics very well. We can use them for any type.

Generic Class

Like C++, we use <> to specify parameter types in generic class creation. To create objects of generic class, we use following syntax.

// To create an instance of generic class
BaseType <Type> obj = new BaseType <Type>()
Note: In Parameter type we can not use primitives like
'int','char' or 'double'.

filter_none

editclose

play_arrow

linkbrightness_4code

// A Simple Java program to show working of user defined

// Generic classes

// We use < > to specify Parameter type

classTest<T>

{

// An object of type T is declared

T obj;

Test(T obj) { this.obj = obj; } // constructor

publicT getObject() { returnthis.obj; }

}

// Driver class to test above

classMain

{

publicstaticvoidmain (String[] args)

{

// instance of Integer type

Test <Integer> iObj = newTest<Integer>(15);

System.out.println(iObj.getObject());

// instance of String type

Test <String> sObj =

newTest<String>("GeeksForGeeks");

System.out.println(sObj.getObject());

}

}

chevron_right

filter_none

Output:

15
GeeksForGeeks

We can also pass multiple Type parameters in Generic classes.

filter_none

editclose

play_arrow

linkbrightness_4code

// A Simple Java program to show multiple

// type parameters in Java Generics

// We use < > to specify Parameter type

classTest<T, U>

{

T obj1; // An object of type T

U obj2; // An object of type U

// constructor

Test(T obj1, U obj2)

{

this.obj1 = obj1;

this.obj2 = obj2;

}

// To print objects of T and U

publicvoidprint()

{

System.out.println(obj1);

System.out.println(obj2);

}

}

// Driver class to test above

classMain

{

publicstaticvoidmain (String[] args)

{

Test <String, Integer> obj =

newTest<String, Integer>("GfG", 15);

obj.print();

}

}

chevron_right

filter_none

Output:

GfG
15

Generic Functions:

We can also write generic functions that can be called with different types of arguments based on the type of arguments passed to generic method, the compiler handles each method.

Programs that uses Generics has got many benefits over non-generic code.

Code Reuse: We can write a method/class/interface once and use for any type we want.

.

Type Safety : Generics make errors to appear compile time than at run time (It’s always better to know problems in your code at compile time rather than making your code fail at run time). Suppose you want to create an ArrayList that store name of students and if by mistake programmer adds an integer object instead of string, compiler allows it. But, when we retrieve this data from ArrayList, it causes problems at runtime.

filter_none

editclose

play_arrow

linkbrightness_4code

// A Simple Java program to demonstrate that NOT using

// generics can cause run time exceptions

importjava.util.*;

classTest

{

publicstaticvoidmain(String[] args)

{

// Creatinga an ArrayList without any type specified

ArrayList al = newArrayList();

al.add("Sachin");

al.add("Rahul");

al.add(10); // Compiler allows this

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

String s2 = (String)al.get(1);

// Causes Runtime Exception

String s3 = (String)al.get(2);

}

}

chevron_right

filter_none

Output :

Exception in thread "main" java.lang.ClassCastException:
java.lang.Integer cannot be cast to java.lang.String
at Test.main(Test.java:19)

How generics solve this problem?
At the time of defining ArrayList, we can specify that this list can take only String objects.

filter_none

editclose

play_arrow

linkbrightness_4code

// Using generics converts run time exceptions into

// compile time exception.

importjava.util.*;

classTest

{

publicstaticvoidmain(String[] args)

{

// Creating a an ArrayList with String specified

ArrayList <String> al = newArrayList<String> ();

al.add("Sachin");

al.add("Rahul");

// Now Compiler doesn't allow this

al.add(10);

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

String s2 = (String)al.get(1);

String s3 = (String)al.get(2);

}

}

chevron_right

filter_none

Output:

15: error: no suitable method found for add(int)
al.add(10);
^

.

Individual Type Casting is not needed: If we do not use generics, then, in the above example every-time we retrieve data from ArrayList, we have to typecast it. Typecasting at every retrieval operation is a big headache. If we already know that our list only holds string data then we need not to typecast it every time.

filter_none

editclose

play_arrow

linkbrightness_4code

// We don't need to typecast individual members of ArrayList

importjava.util.*;

classTest

{

publicstaticvoidmain(String[] args)

{

// Creating a an ArrayList with String specified

ArrayList <String> al = newArrayList<String> ();

al.add("Sachin");

al.add("Rahul");

// Typecasting is not needed

String s1 = al.get(0);

String s2 = al.get(1);

}

}

chevron_right

filter_none

.

Implementing generic algorithms: By using generics, we can implement algorithms that work on different types of objects and at the same they are type safe too.

This article is contributed by Dharmesh Singh. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above