Building Generic Classes in Java with different types

Building Generic Classes in Java with different types

Java generics help programmers develop code that can be universally executable. Without the specification of a particular data type, the same code can be reused several times for various purposes provided that a generic class and method is defined with an Element <E> type parameter list. Java generics provides developers with the following three advantages:

  1. Type Safety: Type safety states that a generic declaration can thereafter be exemplified with a certain datatype. Once that is done, it acts as a safety shield by not allowing you to store elements of other data types. The following example will illustrate this better:List list = new ArrayList();
    add (10);
    list.add (“10”);

    With Generics, you can particularly define an ArrayList that will store Integers.
    List <Integer> list = new ArrayList <Integer> ();
    list.add (10);
    list.add (“10”);
    //The second addition to the array list will result in a compile-time error as the list can only hold arrays.

  2. No typecasting is needed: Generics does not require you to typecast anymore.List list = new ArrayList ();
    add (“Hello World”);
    String s = (String) list.get (0); //typecasting without generics

    List <String> list = new ArrayList <String> ();
    list.add (“Hello”);
    String s = list.get (0); //No type casting required

  3. Compile-Time Checking: All the checks are conducted in compile-time. Therefore, your program will not run into errors at run-time.

Let us look at a few types in generic classes.

Java Generics Using Map

Generic classes can be created using map elements. For maps, we need the passkey and value.

import java.util.*;
class MapDemo
{
public static void main (Strings args [])
{
Map <Integer, String> map = new HashMap <Integer, String> ();
map.put (1, “Agni”);
map.put (4, “Yuvraj”);
map.put (2, “Sulagna”);
Set <Map.Entry <Integer, String> > set = map.entrySet();
Iterator <Map.Entry <Integer, String>> itr = set.iterator ();
while (itr.hasNext ())
{
Map.Entry e = itr.next();
System.out.println (e.getKey() + “ ” + e.getValue());
}
}
}

 

OUTPUT

1 Agni
2 Sulagna
4 Yuvraj

Type Parameters

  1. T – Type
  2. E – Element
  3. K – Key
  4. N – Number
  5. V – Value

Wildcard in Java Generics

The wildcard element is represented by a question mark (?) which denotes that the wild card can be of any type. As an example, consider the code snippet <? extends Number>. This means any child class of Number, namely int, float, and double can be called through the child class objects mentioned before. Wildcards can be used either as a type parameter, field, return type or local variable. The restriction regarding wildcard is it cannot be used as a type argument for a generic method invocation, a generic class instance creation, or supertype.

Sample Code

import java.util.*;
abstract class Shape {
abstract void draw ();
}
class Rectangle extends Shape
{
void draw ()
{
System.out.println (“drawing rectangle”);
}
}
class Circle extends Shape
{
void draw ()
{
System.out.println (“drawing circle”);
}
}
class Demo
{
public static void drawShpaes (List <? extends Shape lists)
for (Shaoe s: lists)
{
s.draw ();
}
}
public static void main (String args [])
{
List <Rectangle> list1 = new ArrayList <Rectangle > ();
list1.add (new Rectangle ());
List <Circle> list2 = new ArrayList <Circle> ();
list2.add (new Circle ());
list2.add (new Circle ());
drawShapes (list1);
drawShapes (list 2);
}
}

 

OUTPUT

drawing rectangle
drawing circle
drawing circle

Leave a comment

This site uses Akismet to reduce spam. Learn how your comment data is processed.