{"id":77313,"date":"2020-03-20T10:12:16","date_gmt":"2020-03-20T04:42:16","guid":{"rendered":"https:\/\/techvidvan.com\/tutorials\/?p=77313"},"modified":"2020-03-20T10:12:16","modified_gmt":"2020-03-20T04:42:16","slug":"java-generics","status":"publish","type":"post","link":"https:\/\/techvidvan.com\/tutorials\/java-generics\/","title":{"rendered":"Java Generics – Get one step closer to become a Java Expert!"},"content":{"rendered":"

Suppose we have to make a list of human beings living in society. It doesn’t matter whether it’s a child, teen or adult. All that matters is they should be human. In such cases, we will not categorize them and will group them as a “Human Being”.<\/p>\n

Similarly in Java when we store data we focus on the content and not datatype and that’s where Generics are used. Java Generics is a programming-language feature that allows for the definition and use of generic methods and generic types.<\/p>\n

Today in this Java tutorial, we are going to study the Generics in Java and it’s Class with multiple parameters. We will also discuss various features and functions of generics in Java.<\/p>\n

At last, we will learn how to use generics in Java to improve the quality of the code with the help of examples.<\/p>\n

\"Java<\/a><\/p>\n

Java Generics<\/h3>\n

Java introduced the concept of Generics since Java 5 (J2SE 5) to deal with compile-time type checking and removing the risk of ClassCastException<\/strong> that was common while working with collection classes. Generics in Java is one of the most important features introduced since Java 5.<\/p>\n

The term Generics in Java represents a set of features in a language, that relates to defining and using the generic methods and types. In Java, Generic methods and types are different from regular methods and types. They differ from each other as generic methods have type parameters.<\/p>\n

We can see Java Generics as the templates in C++<\/strong>. Using Java Generics, we can use the wrapper classes like Integer, String, Double, etc and user-defined types as the parameters to classes, methods, and interfaces.<\/p>\n

We can utilize the generics for any kind. For example,\u00a0classes like HashSet, ArrayList, HashMap, etc use the Java Generics very well.<\/p>\n

Need for Java Generics<\/h3>\n

Java Generics allow us to write a single method that could be able to perform operations in various types of objects that support that method.<\/p>\n

Using Java Generic classes and methods, programmers can specify a set of related methods with a single\/generic method declaration, or with a single class declaration.<\/p>\n

For example, the Java Generics concept allows us to write a generic method for sorting an array of different types of objects, like to invoke the generic method with Character arrays, Integer arrays, String arrays, Double arrays and so on to sort the array elements.<\/p>\n

Moreover, Java Generics provide compile-time type safety that allows the programmers to catch invalid types or faults during compilation.<\/p>\n

Get to know more about Java Array<\/a> in detail with Techvidvan.<\/strong><\/em><\/p>\n

Java Generic Classes<\/h3>\n

A generic class is a class that can refer to any type. To create a generic class of a specific type, we put the T type parameter. The angular brackets <><\/strong> are used to specify parameter types in Java generic class creation.<\/p>\n

Dive a little deep into the concept of Classes in Java<\/a> to clear your basics.<\/strong><\/em><\/p>\n

Let\u2019s discuss a simple example to create and use the generic class.<\/p>\n

Creating a Generic Class<\/h3>\n

The declaration of a generic class is similar to a non-generic class declaration, the only difference is that the generic class name is followed by a type parameter section. The following code shows the creation of a generic class.<\/p>\n

class MyGenClass<T>\n{\n       T obj;\n       void add(T obj)\n       {\n              this.obj=obj;\n       }\n       T getObj()\n       {\n              return obj;\n       }\n}<\/pre>\n
Here, the type T indicates that it can refer to any type of class like Integer, String, Double, Character, and Employee, etc. The specified type of class will store and retrieve the data of the same type.<\/p>\n
Note:<\/strong> In Parameter type, we cannot use primitives data types like \u2018int\u2019,\u2019char\u2019 or \u2018double\u2019, etc.<\/em><\/p>\n
Using a Generic Class<\/h3>\n
class TestGenerics3\n{\n       public static void main(String args[])\n       {\n              MyGenClass<Integer> myObj = new MyGenClass<Integer>();\n              myObj.add(18);\n              \/\/myObj.add(\"TechVidvan\"); \/\/Compile-time error\n              System.out.println(myObj.getObj());\n       }\n}<\/pre>\n
Output:<\/strong><\/p>\n
18<\/div>\n
Code to understand Generic Classes:<\/strong><\/p>\n
package com.techvidvan.javagenerics;\n\/\/ We use < > to specify Parameter type\nclass MyGenericClass<T>\n{\n  \/\/ Declaring an object of type T\n  T obj;\n  \/\/ constructor\n  MyGenericClass(T obj)\n  {\n    this.obj = obj;\n  }\n  public T getObject()\n  {\n    return this.obj;\n  }\n}\nclass GenericClassDemo\n{\n  public static void main (String[] args)\n  {\n    \/\/Using Generic class for Integers\n    MyGenericClass <Integer> intObj = new MyGenericClass<Integer>(15);\n    System.out.println(intObj.getObject());\n\n    \/\/Using Generic class for String\n    MyGenericClass<String> stringObj = new MyGenericClass<String>(\"TechVidvan\");\n    System.out.println(stringObj.getObject());\n  }\n}<\/pre>\n
Output:<\/strong><\/p>\n
15
\nTechVidvan<\/div>\n
Using Multiple type Parameters in Generic Classes<\/h3>\n
We can also use multiple parameters of different types in a generic class, that is, the parameter type section of a generic class can have more than one type of parameter separated by commas.<\/p>\n
These classes are known as parameterized classes<\/strong> since they accept more than one parameter.<\/p>\n
Code to illustrate multiple type Parameters in Generic Classes:<\/strong><\/p>\n
package com.techvidvan.javagenerics;\nclass Test<T, U>\n{\n  T obj1; \/\/ An object of type T\n  U obj2; \/\/ An object of type U\n  \/\/ constructor\n  Test(T obj1, U obj2)\n  {\n    this.obj1 = obj1;\n    this.obj2 = obj2;\n  }\n  \/\/ To print objects of T and U\n  public void getObject()\n  {\n    System.out.println(\u201cString value: \u201c +obj1);\n    System.out.println(\u201cInteger value: \u201d +obj2);\n  }\n}\nclass Main\n{\n  public static void main (String[] args)\n  {\n    Test <String, Integer> obj = new Test<String, Integer>(\"TechVidvan\", 15);\n    obj.getObject();\n  }\n}<\/pre>\n
Output:<\/strong><\/p>\n
String value: TechVidvan
\nInteger value: 15<\/div>\n
Type Parameters<\/h4>\n
The type parameter\u2019s naming conventions are crucial for learning generics thoroughly. The common type parameters are as follows:<\/p>\n
    \n
  1. T – Type<\/li>\n
  2. E – Element<\/li>\n
  3. K – Key<\/li>\n
  4. N – Number<\/li>\n
  5. V – Value<\/li>\n<\/ol>\n
    Java Generic Methods<\/h3>\n
    We can declare a single generic method and we can call this method with arguments of different types. The compiler handles each method call appropriately according to the types of the arguments passed to the generic method.<\/p>\n
    Rules to define Generic Methods<\/h3>\n