Java Generics


It would be pleasant if we might write a solitary sort technique that possibly will class the elements in a numeral collection, a String range, or an array of any category that prop ups ordering.

Java Generic techniques and generic classes allow programmers to state, with a solitary method statement, a set of connected techniques, or with an on its own class statement, a set of connection types, correspondingly.

Generics also offer compile-time sort security that permits programmers to grasp unfounded types at an accumulated time.

With Java Generic idea, we strength write a generic technique for sorting a collection of objects, then appeal to the generic process with Integer collections, Double, String and sort the array elements.

Generic Methods

You could write a solo generic technique declaration that could be called with rows of diverse types. Anchored in the kinds of arguments bypassed to the broad process, the compiler knobs each process call properly. Subsequent are the regulations to characterize Generic Methods −

  • Entire generic technique statements have a kind parameter part delimited by point of view brackets (< and >) that head the method's go-back type ( < E > in the next example).
  • Every type of stricture section encloses one or more kind parameters divided by commas. A kind parameter, also recognized as a kind changeable, is an identifier that specifies a generic type name.
  • The sort parameters can be employed to state the return kind and proceed as placeholders for the kinds of arguments overtook to the broad method, which is identified as actual sort arguments.
  • A common method's remains are affirmed like that of any further method. Note that kind parameters can symbolize only orientation types, not primordial types (like int, double, and char).


The following example illustrates how we can print an array of different types using a single Generic method:

public class GenericMethodTest {
   // generic method printArray
   public static < E > void printArray( E[] inputArray ) {
      // Display array elements
      for(E element : inputArray) {
         System.out.printf("%s ", element);

   public static void main(String args[]) {
      // Create arrays of Integer, Double and Character
      Integer[] intArray = { 1, 2, 3, 4, 5 };
      Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
      Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };

      System.out.println("Array integerArray contains:");
      printArray(intArray);   // pass an Integer array

      System.out.println("\nArray doubleArray contains:");
      printArray(doubleArray);   // pass a Double array

      System.out.println("\nArray characterArray contains:");
      printArray(charArray);   // pass a Character array

This will produce the following result:


Array integerArray contains:
1 2 3 4 5 

Array doubleArray contains:
1.1 2.2 3.3 4.4 

Array characterArray contains:

Bounded Type Parameters

There might be instances when you will desire to limit the types of types that are authorized to be passed to a category parameter. For instance, a process that activates on numbers force only want to acknowledge examples of Number or its subclasses. This is what jumped type parameters are for.

To state abounded kind parameter, catalog the kind parameter's first name, followed by expands keyword, pursued by its higher bound.


The following example illustrates how extends is used in a general sense to mean either "extends" (as in classes) or "implements" (as in interfaces). This example is the Generic method to return the largest of three Comparable objects −

public class MaximumTest {
   // determines the largest of three Comparable objects
   public static <T extends Comparable<T>> T maximum(T x, T y, T z) {
      T max = x;   // assume x is initially the largest
      if(y.compareTo(max) > 0) {
         max = y;   // y is the largest so far
      if(z.compareTo(max) > 0) {
         max = z;   // z is the largest now                 
      return max;   // returns the largest object   
   public static void main(String args[]) {
      System.out.printf("Max of %d, %d and %d is %d\n\n", 
         3, 4, 5, maximum( 3, 4, 5 ));

      System.out.printf("Max of %.1f,%.1f and %.1f is %.1f\n\n",
         6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ));

      System.out.printf("Max of %s, %s and %s is %s\n","pear",
         "apple", "orange", maximum("pear", "apple", "orange"));

This will produce the following result:


Max of 3, 4 and 5 is 5

Max of 6.6,8.8 and 7.7 is 8.8

Max of pear, apple and orange is pear

Generic Classes

A general class statement seems akin to a non-generic group declaration, excluding that the class name is trailed by a sort parameter section.

As with common processes, the type stricture section of a common class can encompass one or more sort parameters divided by commas. These classes are recognized as parameterized classes or parameterized.


The following example illustrates how we can define a generic class −

public class Box<T> {
   private T t;

   public void add(T t) {
      this.t = t;

   public T get() {
      return t;

   public static void main(String[] args) {
      Box<Integer> integerBox = new Box<Integer>();
      Box<String> stringBox = new Box<String>();
      integerBox.add(new Integer(10));
      stringBox.add(new String("Hello World"));

      System.out.printf("Integer Value :%d\n\n", integerBox.get());
      System.out.printf("String Value :%s\n", stringBox.get());

This will produce the following result:


Integer Value :10
String Value :Hello World

Here at Intellinuts, we have created a complete Java tutorial for Beginners to get started in Java.