Generics were introduced in version J2SE 5.0 of Java in 2004. It is a pure compile-time concept. Before the Generics were not introduced, we had to downcast the and specify it. There were no compile time safety and runtime exceptions like comes into play. To remove these problems Java developers introduced generics.  Simply put, by using the Generics concept, a developer can sort an array of objects and then simply invoke integer, double, and sting arrays to sort the elements. <object type> classCastException Why do we need Generics? Let’s find out why we need Generics with practical examples. Consider a class Java that has a private member of Type Object (Object class is the mother of all classes as every class is a child class of Object Class). class Java{ private Object obj1; public Object getObj1() { return obj1; } public void setObj1(Object obj) { this.obj1 = obj; } } Let’s assume, a developer Adam creates an instance of the Java class and stores a Date object in its variable. The object of Date is taken from Java.sql.Date Adam: Java temporary = new Java(); temporary.setObj1(new Date(someTime)); // java.sql.Date And another developer David sets a Date instance in the same project from instance. Java.util.Date David: ** ** temporary.Obj1(new Date()); // java.uitil.Date Now, if Adam tries to fetch date from the same temporary instance and tries to assign it to the Date variable of (since he used it earlier), he will get a at run time. java.sql.Date classCastException Adam: Date date = (Date)temp.get(); // java.sql.Date We had to face these problem before Generics were introduced. Developers had to use an explicit downcast of objects and runtime exceptions like came into play. classCastExceptions To tackle these sorts of problems Java language designers were looking for a solution that can help them to deal with such exceptions at compile time. They eventually found the solution and added the Generics concept into Java version5. Consider the same class Java defined in terms of Generics. class Java<T>{ private T obj1; public T getObj1() { return obj1; } public void setObj1(T obj) { this.obj1 = obj; } ** ** } Here is a parameterized type.** ** <T> Now when Adam creates an instance of class Java and stores an object of Date from java.sql.Date. Adam: Java<Date> temporary = new Java<Date>();  // java.sql.Date temporary.setObj1(new Date(someTime)); And later David tries to set the same instance (temporary) with a new Object of Date from java.util.Date David: temporary.setObj1(new Date()); // java.util.Date If David tries to do so he will get a compile-time error. As temporary can store only objects of Date from In this way, Generics offer us compile-time safety, much cleaner, less generic code, no downcast of objects, and no runtime exceptions. This is why Generics is called a pure compile-time concept. java.sql.Date Generic Type and parameterized Type Class Java<T> { …. } is a generic type where T in Java is a Type parameter of this Generic type and it is a formal type parameter. <T> Now if we create an instance of the Temp class. Java<Date> temporary = new Java<Date>(); // java.sql.Date Here in this statement is parameterized and Date is an actual parameter that ensures that temporary (instance of Java) can hold only Date-type objects which come from If anyone tries to store any other object in temp, they will get a compilation error. Java<Date> java.sql.Date Diamond notation We can also create an instance of the Java class as follows: Java<Date> temporary = new Java<>(); In this line of code, we do not have to specify the actual type parameter on the right side of creation. The compiler does that implicitly for us and this is known as diamond notation. How the compiler treats Generics As we learned, Generics are tackled by the compiler at compile time. When we compile our code, the compiler does two things for us: and . Let's look at the same example to understand what they are: 1- Type erasure 2- implicit cast public class main { public static void main(String[] args) { Java<String> temporary = new Java<>(); // Diamond notation temporary.setObj1("java version 5"); System.out.println(temporary.getObj1()); } } class Java<T>{ private T obj1; public T getObj1() { return obj1; } public void setObj1(T obj) { this.obj1 = obj; } } When we compile this code, the compiler uses a term called . Type Erasure As the name suggests type erasure basically removes all the generic notation and replaces all class-level type parameters with Object Type. Like in our case when we compile the code, all generic notation will be removed and class-level type parameters will be replaced with Object. Here is what the code looks like after the Type erasure: public class main { public static void main(String[] args) { Java temporary = new Java(); temporary.setObj1("java version 5"); System.out.println((String)temporary.getObj1()); } } class Temp{ private Object obj1; public Object getObj1() { return obj1; } public void setObj1(Object obj) { this.obj1 = obj; } ** ** } As we can see, the compiler does implicit cast in the print statement and uses a type eraser to remove and replace generics notation. Restrictions in Generics There are some restrictions in generics as well and we have to be familiar with them. The first restriction is we can not use primitive types as Type arguments in Generics. For example, we can not do Java<int> temporary = new Java<int>(); Second restriction is that we can not use a class-level type parameter in a static context. For example, we can not do the following: class Java<T>{ private static T obj1; public T getObj1() { return obj1; } public void setObj1(T obj) { this.obj1 = obj; } } This will give a compile time error.** ** Third restriction is that methods can not be overloaded and have the same reference type after Type erasure. For example, we can not do the following: void menu(LinkedList<String> l1){} void menu(LinkedList<Integer> l1){} This is not method overloading as after Type erasure comes into play this piece of code will look like this: void menu(LinkedList l1){} void menu(LinkedList l1){} Type erasure removes all generic notation. Now as you can see both functions are the same and hence no overloading concept is required here. There are a few more restrictions but these are the most important ones. How Generics in java is useful for developers? We developed a strong understanding of generics. We know we can deal with runtime exceptions at compile time itself as generics provide us strong type-checking, and compile-time safety, and also we do not need to use explicit cast as the compiler knows what type is to be stored. So, with this, we have much cleaner, readable, and more generic code. Generics provide the ability for developers to develop generic algorithms. In Java, today use of many features would not be possible without generics.

What are Generics in Java and How do they work? Explained with Examples

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

10 tips to Improve Java Programming Skills in 2020

A Deeper Look at Exceptions in Java

Six ‘Java 9’ API Improvements You Should Know

10 Common Java Vulnerabilities Every Security Engineer Should Know

20 Fun DIY Java Projects To Fine Tune Your Skillset

10 tips to Improve Java Programming Skills in 2020

A Deeper Look at Exceptions in Java

Six ‘Java 9’ API Improvements You Should Know

10 Common Java Vulnerabilities Every Security Engineer Should Know

20 Fun DIY Java Projects To Fine Tune Your Skillset

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps