Generics in java

GENERICS IN JAVA
BYLECTURERSURAJPANDEYCCTCOLLEGE

WHAT ARE GENERICS?
 At its core, the term generics means
parameterized types. Parameterized types are
important because they enable you to create
classes, interfaces, and methods in which the
type of data upon which they operate is specified
as a parameter. Using generics, it is possible to
create a single class, for example, that
automatically works with different types of data.
A class,interface, or method that operates on a
parameterized type is called generic, as in generic
class or generic method.
BYLECTURERSURAJPANDEYCCT
COLLEGE

GENERIC METHODS
 You can write a single generic method declaration that can be called with
arguments of different types. Based on the types of the arguments passed
to the generic method, the compiler handles each method call
appropriately. Following are the rules to define Generic Methods −
 All generic method declarations have a type parameter section delimited
by angle brackets (< and >) that precedes the method's return type ( < E >
in the next example).
 Each type parameter section contains one or more type parameters
separated by commas. A type parameter, also known as a type variable, is
an identifier that specifies a generic type name.
 The type parameters can be used to declare the return type and act as
placeholders for the types of the arguments passed to the generic method,
which are known as actual type arguments.
 A generic method's body is declared like that of any other method. Note
that type parameters can represent only reference types, not primitive
types (like int, double and char).
COLLEGE

 Example
 Following example illustrates how we can print
an array of different type using a single Generic
method −
COLLEGE

COLLEGE
Output
Array integerArray
contains: 1 2 3 4 5
Array doubleArray
contains: 1.1 2.2 3.3
4.4 Array
characterArray
contains: H E L L O

BOUNDED TYPE PARAMETERS
 There may be times when you'll want to restrict the kinds
of types that are allowed to be passed to a type parameter.
For example, a method that operates on numbers might
only want to accept instances of Number or its subclasses.
This is what bounded type parameters are for.
 To declare a bounded type parameter, list the type
parameter's name, followed by the extends keyword,
followed by its upper bound.
 Example
 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 Generic
method to return the largest of three Comparable objects −
COLLEGE

COLLEGE

 Output
 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
COLLEGE

GENERICS WORK ONLY WITH REFERENCE
TYPES
 When declaring an instance of a generic type, the
type argument passed to the type parameter
must be a reference type. You cannot use a
primitive type, such as int or char.
 For example, with Gen, it is possible to pass
any class type to T, but you cannot pass a
primitive type to a type parameter. Therefore,
the following declaration is illegal:
 Gen<int> intOb = new Gen<int>(53); // Error,
can't use primitive type
COLLEGE

GENERIC CLASSES
 A generic class declaration looks like a non-
generic class declaration, except that the class
name is followed by a type parameter section.
 As with generic methods, the type parameter
section of a generic class can have one or more
type parameters separated by commas. These
classes are known as parameterized classes or
parameterized types because they accept one or
more parameters.
 Example
 Following example illustrates how we can define
a generic class −
COLLEGE

A GENERIC CLASS WITH TWO TYPE
PARAMETERS
 You can declare more than one type parameter in
a generic type. To specify two or more type
parameters, simply use a comma-separated list.
For example, the following TwoGen class is a
variation of the Gen class that has two type
parameters:
COLLEGE

 // A simple generic class with two type
 // parameters: T and V.
class TwoGen<T, V> {
T ob1;
V ob2;
 // Pass the constructor a reference to
 // an object of type T and an object of type V.
TwoGen(T o1, V o2) {
ob1 = o1;
ob2 = o2;
}
 // Show types of T and V.
void showTypes() {
System.out.println("Type of T is " +
ob1.getClass().getName());
System.out.println("Type of V is " +
ob2.getClass().getName());
}
T getob1() {
return ob1;
}
COLLEGE

V getob2() {
return ob2;
}
}
// Demonstrate TwoGen.
class SimpGen {
public static void main(String args[]) {
TwoGen<Integer, String> tgObj =
new TwoGen<Integer, String>(88, "Generics");
 // Show the types.
tgObj.showTypes();
 // Obtain and show values.
int v = tgObj.getob1();
System.out.println("value: " + v);
String str = tgObj.getob2();
System.out.println("value: " + str);
 }
 }
COLLEGE

 The output from this program is shown here:
 Type of T is java.lang.Integer
 Type of V is java.lang.String
 value: 88
 value: Generics
COLLEGE

 Notice how TwoGen is declared:
 class TwoGen<T, V> {
 It specifies two type parameters: T and V, separated by a
comma. Because it has two type parameters, two type
arguments must be passed to TwoGen when an object is
created, as shown next:
 TwoGen<Integer, String> tgObj = new TwoGen<Integer,
String>(88, "Generics");
 In this case, Integer is substituted for T, and String is
substituted for V.
 Although the two type arguments differ in this example, it is
possible for both types to be the same. For example, the following
line of code is valid:
 TwoGen<String, String> x = new TwoGen<String, String> ("A",
"B");
 In this case, both T and V would be of type String. Of course, if
the type arguments were always the same, then two type
parameters would be unnecessary.
COLLEGE

THE GENERAL FORM OF A GENERIC
CLASS
 The generics syntax shown in the preceding
examples can be generalized. Here is the
 syntax for declaring a generic class:
 class class-name<type-param-list > { // …
 Here is the full syntax for declaring a reference
to a generic class and instance creation:
 class-name<type-arg-list > var-name = new class-
name<type-arg-list >(cons-arg-list);
COLLEGE

 Bounded Types
 In the preceding examples, the type parameters
could be replaced by any class type. This is fine
for many purposes, but sometimes it is useful to
limit the types that can be passed to a type
parameter. For example, assume that you want
to create a generic class that contains a method
that returns the average of an array of numbers.
Furthermore, you want to use the class to obtain
the average of an array of any type of number,
including integers, floats, and doubles. Thus,
you want to specify the type of the numbers
generically, using a type parameter.
COLLEGE

 To create such a class, you might try something like this:
 // Stats attempts (unsuccessfully) to
 // create a generic class that can compute
 // the average of an array of numbers of
 // any given type.
 //
 // The class contains an error!
class Stats<T> {
T[] nums; // nums is an array of type T
 // Pass the constructor a reference to
 // an array of type T.
Stats(T[] o) {
nums = o;
}
 // Return type double in all cases.
double average() {
double sum = 0.0;
for(int i=0; i < nums.length; i++)
sum += nums[i].doubleValue(); // Error!!!
return sum / nums.length;
 }
 }
COLLEGE

 Creating a Generic Method
 As the preceding examples have shown, methods
inside a generic class can make use of a class’
type parameter and are, therefore, automatically
generic relative to the type parameter.
 However, it is possible to declare a generic
method that uses one or more type parameters of
its own. Furthermore, it is possible to create a
generic method that is enclosed within a non-
generic class.
COLLEGE

 Let’s begin with an example. The following
program declares a non-generic class called
 GenMethDemo and a static generic method
within that class called isIn( ). The isIn( )
method determines if an object is a member of an
array. It can be used with any type of object and
array as long as the array contains objects that
are compatible with the type of the object being
sought.
COLLEGE

 // Demonstrate a simple generic method.
 class GenMethDemo {
 // Determine if an object is in an array.
static <T extends Comparable<T>, V extends T> boolean isIn(T x,
V[] y) {
for(int i=0; i < y.length; i++)
if(x.equals(y[i])) return true;
return false;
}
public static void main(String args[]) {
 // Use isIn() on Integers.
Integer nums[] = { 1, 2, 3, 4, 5 };
if(isIn(2, nums))
System.out.println("2 is in nums");
if(!isIn(7, nums))
System.out.println("7 is not in nums");
System.out.println();
COLLEGE

 // Use isIn() on Strings.
String strs[] = { "one", "two", "three", "four", "five"
};
if(isIn("two", strs))
System.out.println("two is in strs");
if(!isIn("seven", strs))
System.out.println("seven is not in strs");
 // Oops! Won't compile! Types must be
compatible.
 // if(isIn("two", nums))
 // System.out.println("two is in strs");
}
}
COLLEGE

 The output from the program is shown here:
 2 is in nums
 7 is not in nums
 two is in strs
 seven is not in strs
COLLEGE

 Generic Types
 A generic type is a generic class or interface that is
parameterized over types. The following Box class will be
modified to demonstrate the concept.
 A Simple Box Class
 Begin by examining a non-generic Box class that operates on
objects of any type. It needs only to provide two methods: set,
which adds an object to the box, and get, which retrieves it:
 public class Box { private Object object; public void set(Object
object) { this.object = object; } public Object get() { return
object; } }
 Since its methods accept or return an Object, you are free to
pass in whatever you want, provided that it is not one of the
primitive types. There is no way to verify, at compile time,
how the class is used. One part of the code may place an
Integer in the box and expect to get Integers out of it, while
another part of the code may mistakenly pass in a String,
resulting in a runtime error.
COLLEGE

 Type Parameter Naming Conventions
 By convention, type parameter names are single,
uppercase letters. This stands in sharp contrast to the
variable naming conventions that you already know
about, and with good reason: Without this convention,
it would be difficult to tell the difference between a
type variable and an ordinary class or interface name.
 The most commonly used type parameter names are:
 E - Element (used extensively by the Java Collections
Framework)
 K - Key
 N - Number
 T - Type
 V - Value
 S,U,V etc. - 2nd, 3rd, 4th types
COLLEGE

 Hierarchy and classification
 According to Java Language Specification:
 A type variable is an unqualified identifier. Type variables are introduced by generic class
declarations, generic interface declarations, Generic method declarations, and by generic
constructor declarations.
 A class is generic if it declares one or more type variables. These type variables are known
as the type parameters of the class. It defines one or more type variables that act as
parameters. A generic class declaration defines a set of parameterized types, one for each
possible invocation of the type parameter section. All of these parameterized types share
the same class at runtime.
 An interface is generic if it declares one or more type variables. These type variables are
known as the type parameters of the interface. It defines one or more type variables that
act as parameters. A generic interface declaration defines a set of types, one for each
possible invocation of the type parameter section. All parameterized types share the same
interface at runtime.
 A method is generic if it declares one or more type variables. These type variables are
known as the formal type parameters of the method. The form of the formal type parameter
list is identical to a type parameter list of a class or interface.
 A constructor can be declared as generic, independently of whether the class that the
constructor is declared in is itself generic. A constructor is generic if it declares one or more
type variables. These type variables are known as the formal type parameters of the
constructor. The form of the formal type parameter list
 is identical to a type parameter list of a generic class or interface.
COLLEGE

 The Java Generics programming is introduced
in J2SE 5 to deal with type-safe objects.
 Before generics, we can store any type of objects
in collection i.e. non-generic. Now generics, forces
the java programmer to store specific type of
objects.
COLLEGE

 Advantage of Java Generics
 There are mainly 3 advantages of generics. They are as
follows:
 1) Type-safety : We can hold only a single type of objects
in generics. It doesn’t allow to store other objects.
 2) Type casting is not required: There is no need to
typecast the object.
 Before Generics, we need to type cast.
1. List list = new ArrayList();
2. list.add("hello");
3. String s = (String) list.get(0);//typecasting
 After Generics, we don't need to typecast the object.
1. List<String> list = new ArrayList<String>();
3. String s = list.get(0);
COLLEGE

 3) Compile-Time Checking: It is checked at
compile time so problem will not occur at
runtime. The good programming strategy says it
is far better to handle the problem at compile
time than runtime.
1. List<String> list = new ArrayList<String>();
3. list.add(32);//Compile Time Error
 Syntax to use generic collection
 ClassOrInterface<Type>
 Example to use Generics in java
 ArrayList<String>
COLLEGE

FULL EXAMPLE OF GENERICS IN
JAVA
 Here, we are using the ArrayList class, but you
can use any collection class such as ArrayList,
LinkedList, HashSet, TreeSet, HashMap,
Comparator etc.
COLLEGE

 import java.util.*;
 class TestGenerics1{
 public static void main(String args[]){
 ArrayList<String> list=new ArrayList<String>();
 list.add("rahul");
 list.add("jai");
 //list.add(32);//compile time error
 String s=list.get(1);//type casting is not required
 System.out.println("element is: "+s);
 Iterator<String> itr=list.iterator();
 while(itr.hasNext()){
 System.out.println(itr.next());
 }
 }
 }
 Output:element is: jai
 rahul
 jai
COLLEGE

 Example of Java Generics using Map
 Now we are going to use map elements using
generics. Here, we need to pass key and value.
Let us understand it by a simple example:
COLLEGE

 import java.util.*;
 Map<Integer,String> map=new HashMap<Integer,String>();
 map.put(1,"vijay");
 map.put(4,"umesh");
 map.put(2,"ankit");
 //Now use Map.Entry for Set and Iterator
 Set<Map.Entry<Integer,String>> set=map.entrySet();
 Iterator<Map.Entry<Integer,String>> itr=set.iterator();
 while(itr.hasNext()){
 Map.Entry e=itr.next();//no need to typecast
 System.out.println(e.getKey()+" "+e.getValue());
 }
 }}
 Output:1 vijay
 2 ankit
 4 umesh
COLLEGE

GENERIC CLASS
 A class that can refer to any type is known as
generic class. Here, we are using T type
parameter to create the generic class of specific
type.
 Let’s see the simple example to create and use
the generic class.
COLLEGE

 Creating generic class:
 class MyGen<T>{
 T obj;
 void add(T obj){this.obj=obj;}
 T get(){return obj;}
 }
 The T type indicates that it can refer to any type
(like String, Integer, Employee etc.). The type
you specify for the class, will be used to store and
retrieve the data.
COLLEGE

 Using generic class:
 Let’s see the code to use the generic class.
 MyGen<Integer> m=new MyGen<Integer>();
 m.add(2);
 //m.add("vivek");//Compile time error
 System.out.println(m.get());
 }}
 Output:2
COLLEGE

 Type Parameters
 The type parameters naming conventions are
important to learn generics thoroughly. The
commonly type parameters are as follows:
 T - Type
 E - Element
 K - Key
 N - Number
 V - Value
COLLEGE

 Generic Method
 Like generic class, we can create generic method
that can accept any type of argument.
 Let’s see a simple example of java generic
method to print array elements. We are using
here E to denote the element.
COLLEGE

 public class TestGenerics4{
    public static < E > void printArray(E[] elements) {
         for ( E element : elements){
             System.out.println(element );
          }
          System.out.println();
     }
     public static void main( String args[] ) {
         Integer[] intArray = { 10, 20, 30, 40, 50 };
         Character[] charArray = { 'J', 'A', 'V', 'A', 'T','P','O','I','N','T'
};
         System.out.println( "Printing Integer Array" );
         printArray( intArray  );
        System.out.println( "Printing Character Array" );
         printArray( charArray );
     }
 }
COLLEGE

 Output:Printing Integer Array
 10
 20
 30
 40
 50
 Printing Character Array
 J
 A
 V
 A
 T
 P
 O
 I
 N
 T
COLLEGE

Generics in java

More Related Content

What's hot (20)

Similar to Generics in java (20)

More from suraj pandey (20)

Recently uploaded (20)

Generics in java