Object Oriented Using Java -
Generic in Java
PRESENTED BY:
ANSHU SHARMA
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
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'.
EXAMPLES: GENERIC CLASS
/ A Simple Java program to show working of user defined Generic classes
// We use < > to specify Parameter type
class Test<T>
{
// An object of type T is declared
T obj;
Test(T obj)
{
this.obj = obj;
} // constructor
public T getObject()
{
return this.obj;
}
}
EXAMPLE CONTD.
class Main
{
public static void main (String[] args)
{
// instance of Integer type
Test <Integer> iObj = new Test<Integer>(15);
System.out.println(iObj.getObject());
// instance of String type
Test <String> sObj =
new Test<String>("GeeksForGeeks");
System.out.println(sObj.getObject());
}
}
MULTIPLE TYPE PARAMETERS IN GENERIC CLASSES
We can also pass multiple Type parameters in Generic classes.
// A Simple Java program to show multiple
// type parameters in Java Generics
// We use < > to specify Parameter type
class Test<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;
}
EXAMPLE CONTD.
// To print objects of T and U
public void print()
{
System.out.println(obj1);
System.out.println(obj2);
}
}
// Driver class to test above
class Main
{
public static void main (String[] args)
{
Test <String, Integer> obj =
new Test<String, Integer>("GfG", 15);
obj.print();
}
}
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.
EXAMPLE:
// A Simple Java program to show working of user defined
// Generic functions
class Test
{
// A Generic method example
static <T> void genericDisplay (T element)
{
System.out.println(element.getClass().getName() +
" = " + element);
}
EXAMPLE CONTD.
// Driver method
public static void main(String[] args)
{
// Calling generic method with Integer argument
genericDisplay(11);
// Calling generic method with String argument
genericDisplay("GeeksForGeeks");
// Calling generic method with double argument
genericDisplay(1.0);
}
}
ADVANTAGES OF JAVA GENERICS
1. Code Reusability
Generics allow us to write code that will work
with different types of data. For example,
public <T> void genericsMethod(T data) {...}
Here, we have created a generics method. This
method can be used to perform operations on
integer data, string data and so on.
ADVANTAGES CONTD.
2. Compile-time Type Checking
The type parameter of generics provides information about the type
of data used in the generics code.
Hence, any error can be identified at compile time which is easier to
fix than runtime errors. For example,
// without using Generics
NormalClass list = new NormalClass(); // calls method of
NormalClass
list.display("String");
In the above code, we have a normal class. We call the method named
display() of this class by passing a string data.
Here, the compiler does not know if the value passed in the argument
is correct or not.
ADVANTAGES CONTD.
However, let's see what will happen if we use the generics
class instead.
// using Generics
GenericsClass<Integer> list = new GenericsClass<>(); //
calls method of GenericsClass
list2.display("String");
In the above code, we have a generics class. Here, the type
parameter indicates that the class is working on Integer
data. Hence when the string data is passed in argument, the
compiler will generate an error.
