Restrictions on Generics in Java

In Java, Generics are the parameterized types that allow us to create classes, interfaces, and methods in which the type of data they are dealing with will be specified as a parameter. This ensures the type safety at the compilation time. 

Syntax

class class_name<T>
{ 
 //Body of the class 
}  

Here, the T is a type parameter that can be replaced with any valid identifier. Similarly, generic methods and interfaces are also created.

Restrictions of Generics in Java

There are a few restrictions associated with the usage of generics that are mentioned below:

• Type parameters cannot be instantiated
• Restriction on using static members
• Generic array Restrictions
• primitive data types are not used with generic types
• Generic Exception Restriction

1. Type parameters cannot be instantiated

It is not possible to create an instance of a type parameter. The compiler doesn't know what type of object to create, their T is simply a placeholder. Below is the example code that shows the invalid creation of an instance of T which leads to a compilation error.

Example:

10

2. Restriction on using static members

It is illegal for the static members(variables, methods) to use a type parameter declared by the enclosing class. We will use the above example in this case to make the variable and method static, this also leads to compile time error. Let's see in detail what the compiler says:

Example:

Geek For Geeks!!

3. Generic array Restrictions

There are two important generic restrictions that applied to arrays.

1. We cannot instantiate an array whose element type is a type parameter. There is no way for the compiler to know what type of array to actually create. However, we can pass a reference to a type-compatible array as a parameter and assign it to the object created. This is acceptable because the array passed as a parameter has a known type, which will be of the same type as T at the time of object creation.
2. We cannot create an array of type-specific generic references. The reason could be the same as in the above case the compiler doesn't know what kind of array to create. This can be resolved by using a wildcard, which is better than using a raw type because at least some type checking will be done. 

Example:

value: 10
[1, 2, 3, 4, 5]

4. Primitive data types are not used with the generic types

We will get the compilation error if we use the primitive data types at the time of object creation. The following code demonstrates the situation:

Example:

value: 10
value: Geek For Geeks

5. Generic Exception Restriction

We cannot create generic exception classes and cannot extend throwable (which is superior to all exception classes in the exception class hierarchy).  We will use the above example to understand this, although we get an error if we execute this code, give it a try. 

Example:

Output:

Error: Could not find or load main class Box
Caused by: java.lang.ClassNotFoundException: Box