With the objective of decreasing bugs and adding an additional layer of abstraction over types, Java Generics was implemented in JDK 5.0.
This article is a fast introduction to Java's generics, the objective behind them and how they can be used to enhance our code quality.
Java generics are similar to C++ templates. The concept is to allow type (Integer, String, ... and types identified by the user) to be a parameter for methods, classes, and interfaces. For example, classes such as HashSet, ArrayList, HashMap, etc., use generics well. They can be used for any type.
Generics-using programs have many advantages over the non-generic code.
Syntax to create a generic type object:
Class_name <java data type> reference_name = new Class_name<data type> (); OR Class_name <java data type> reference_name = new Class_name<>();
This is also referred to as the Diamond Notation producing a generic type object.
Example of Generic class
class Gen <T> //<> brackets indicates that the class is of generic type { T ob; //an object of type T is declared Gen(T o) //constructor { ob = o; } public T getOb() { return ob; } } class Test { public static void main (String[] args) { Gen <Integer> iob = new Gen<>(150); int x = iob.getOb(); System.out.println(x); Gen < String> sob = new Gen<>("Hello John"); String str = sob.getOb(); System.out.println(str); } }
Output:
150 Hello John
We passed an Integer type parameter to the Generic class for the first time in the above program. Then we passed the same generic class with a String type parameter. Therefore, for two distinct data types, we reused the same class. Generics thus facilitate the reusability of code.
Generics only work with objects, i.e. the type argument must be a class type. You can't use primitive data types like int, char, etc. with generic type. It should be an object at all times. As a generic type, we can use all objects of the Wrapper Class and String class objects.
Gen<short> iOb = new Gen<short>(07); //Error, can't use primitive type
Generics Types of different Type Arguments are never same in java
Unless their type reasoning is the same, the reference of one generic type is never consistent with another generic type. In the above example, we created two objects of the Gen class, one of the Integer type and another of the String type.
iob = sob; //Absolutely Wrong
An array of Generic type cannot be created in java
It is not permitted to create a generic type array in generic programming. We can make an array reference, but we can't set it up.
For example, In the above program, in class Gen,
T a[]; //this is allowed T a[] = new T[10]; //this is not allowed
Generic Type with more than one parameter
We can transfer more than 1 data type as a parameter in generic parameter types. It operates the same as with the generic type of one parameter.
class Gen <T1,T2> { T1 name; T2 value; Gen(T1 o1,T2 o2) { name = o1; value = o2; } public T1 getName() { return name; } public T2 getValue() { return value; } } class Test { public static void main (String[] args) { Gen < String,Integer> obj = new Gen<>("MovieTonight",678); String s = obj.getName(); System.out.println(s); Integer i = obj.getValue(); System.out.println(i); } }
Output:
MovieTonight 678
Note: Therefore, as there are two parameters in Generic Class-T1 and T2, while generating an example of this Generic Class, we need to mention two types of information that need to be passed to this class as a parameter.
You can also generate generic methods with various types of arguments that can be called. The compiler handles each method based on the sort of arguments passed to the generic method.
The syntax for a generic method includes a type parameter, inside angle brackets, that should appear before the return type of the method.
<type-parameter> return_type method_name (parameters) {...}
Example of Generic method
class GenTest { static <b>< V, T></b> void display (V v, T t) { System.out.println(v.getClass().getName()+" = " +v); System.out.println(t.getClass().getName()+" = " +t); } public static void main(String[] args) { display(88,"This is string"); } }
Output:
java lang.Integer = 88 java lang.String = This is string
A generic constructor can be created even if the class is not generic.
Example of Generic Constructor
class Gen { private double val; < T extends Number> Gen(T ob) { val=ob.doubleValue(); } void show() { System.out.println(val); } } class Test { public static void main(String[] args) { Gen g = new Gen(100); Gen g1 = new Gen(121.5f); g.show(); g1.show(); } }
Output:
100.0 121.5
You can also generate generic interfaces like classes and methods.
interface MyInterface< T >
{ .. }
You can also set the type restriction that can be passed to a type parameter. This is achieved when specifying the type parameter with the assistance of extends keyword.
< T extends Number >
We took Number class here, it can be any name of the wrapper class. This indicates that only Number class information or any of its subclasses can replace T.
class Gen { static < T, V extends number> void display(T t, V v) { System.out.println(v.getClass().getName()+" = " +v); System.out.println(t.getClass().getName()+" = " +t); } public static void main(String[] args) { // display(98,"This is string"); display ("this is string",99); } }
Output:
java.lang.String = This is string java.lang.Double = 99.O
Keep sharing blogs like this one; they are quite good. You have given everyone in this blog access to a wealth of information.
Thank you for your valuable information.
Thank you for this wonderful article!
This article was really helpful to me, thank you!
super article!
Leave a Reply
Your email address will not be published. Required fields are marked *