Object Oriented Programming (SE 2031)

Chapter 05

Generics

1
Objectives
After studying this chapter, students should be able to learn about:
 Generic Classes
 Generic Methods
 Generic Interfaces

2
Introduction
 Generic type represents classes, interfaces and methods in a
type safe manner.
 Generic types can act on any type of data.
 All Generic types are subclasses of Object class, it acts on
Objects only.
 Generic types act on advanced data type only.
 It is not possible to create an object to Generic type itself.
 Using generic types, we can avoid casting in many cases.

3
Generic Class
 When we create a class with an instance variable to store an
Integer object, it can be used to store Integer type data only. We
cannot use that instance variable to store a Float class object or
a String type Object.
 To store different types of data into a class, we have to write the
same class again and again by changing the data type of the
variables.
 This can be avoided using a generic class.
 A generic class represents a class that is type-safe. This means a
generic class can act upon any data type.
 Generic classes and generic interfaces are also called
‘parameterized types’ because they use a parameter that
determines which data type they should work upon.

4
Generic Class - Example
//Example for Generic Class
class MyClass<T>
{ T obj;
MyClass (T obj)
{
this.obj = obj;
}
T getObj ()
{
return obj;
}
}

5
class Gen1
{ public static void main(String args[])
{
Integer i1 = new Integer (10);
MyClass<Integer> obj1 = new MyClass<Integer>(i1);
System.out.println ("U stored : " + obj1.getObj() );
Double d1 = new Double(30.66);
MyClass<Double> obj2 = new MyClass<Double>(d1);
System.out.println("U Stored: " + obj2.getObj() );
MyClass<String> obj3 = new MyClass<String>(“Sammie");
System.out.println ("U Stored : " + obj3.getObj() );
}
}
Output:
U stored : 10
U stored: 30.66
U stored: Kumar 6
Generic Method
 We can make a method alone as generic method by writing the
generic parameter before the method return type as:

<T> returntype methodname ()

{
//Method body;
}

Ex: <T> void display_data ()

{
//Method body;
}

7
Generic Method - Example
//Generic method example
class MyClass
{
<T>void display_data (T arr[])
{
for (int i=0;i<arr.length; i++)
System.out.print ("\t" + arr[i]);
System.out.println ();
}
}

8
class Gen2
{
public static void main(String args[])
{ MyClass obj = new MyClass ( );
Integer a[] = {1,2,3,4,5,6};
System.out.print ("Reading Integer Objects: ");
obj.display_data (a);

Float b[] = {1.1f,2.2f,3.4f};

System.out.print ("Reading Float Objects: ");
obj.display_data (b);

String c[] = {"Subash","Chandra","Bose"};

System.out.print ("Reading String Objects: ");
obj.display_data (c);
}
}

9
Generic Interface
 It is possible to develop an interface using generic type concept.
 The general form of generic interface looks like:
interface interface_name <T>
{
//method that accepts any object
return_type method_name ( T object_name );
}
 Here, T represents any data type which is used in the interface.
We can write an implementation class for the above interface as:
class class_name <T> implements interface_name <T>
{
public return_type method_name ( T object_name )
{
//provide body of the method
}
}

10
Generic Interface - Example
//A generic interface
interface inter<T>
{
void displayData (T obj);
}
class AnyClass<T> implements inter<T>
{ public void displayData (T t1)
{
System.out.println ("Entered value is : " + t1);
}
}
class Gen3
{ public static void main (String args[])
{ AnyClass<Integer> ob1 = new AnyClass<Integer>();
ob1.displayData (new Integer (10) );
AnyClass<String> ob2 = new AnyClass<String>();
ob2.displayData (new String ("Hari") );
}
}

11
Self- Review Questions
1. Write a generic method to count the number of elements in a
collection that have a specific property (for example, odd
integers, prime numbers, palindromes).
2. Write a generic method to exchange the positions of two
different elements in an array.
Given the following classes:
class Shape { /* ... */ }
class Circle extends Shape { /* ... */ }
class Rectangle extends Shape { /* ... */ }
class Node<T> { /* ... */ }

Will the following code compile? If not, why?

Node<Circle> nc = new Node<>();
Node<Shape> ns = nc;

12