Scribd
Upload
42 views13 pages

Generic Programming in Java

Generics in Java allow types (like Integer and String) to be used as parameters for methods, classes, and interfaces. This allows code reusability and compile-time type checking. Some key points: - Generics are similar to templates in C++ - Angle brackets < > specify type parameters for generic classes - Methods and classes can have multiple type parameters - Generics allow code to work with different data types like Integer and String - Compile-time checking of types prevents runtime errors

Uploaded by

adiya sharma
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
Download as pptx, pdf, or txt
42 views13 pages

Generic Programming in Java

Generics in Java allow types (like Integer and String) to be used as parameters for methods, classes, and interfaces. This allows code reusability and compile-time type checking. Some key points: - Generics are similar to templates in C++ - Angle brackets < > specify type parameters for generic classes - Methods and classes can have multiple type parameters - Generics allow code to work with different data types like Integer and String - Compile-time checking of types prevents runtime errors

Uploaded by

adiya sharma
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
Download as pptx, pdf, or txt
Download as pptx, pdf, or txt
You are on page 1/ 13

Object Oriented Using Java -

Generic in Java

PRESENTED BY:
ANSHU SHARMA
GENERICS IN JAVA
 Generics in Java is similar to templates in C++.
The idea is to allow type (Integer, String, … etc
and user defined types) to be a parameter to
methods, classes and interfaces. For example,
classes like HashSet, ArrayList, HashMap, etc
use generics very well. We can use them for any
type.
GENERIC CLASS
 we use <> to specify parameter types in generic class creation. To
create objects of generic class, we use following syntax.
// To create an instance of generic class
BaseType <Type> obj = new BaseType <Type>()
Note: In Parameter type we can not use primitives like 'int','char'
or 'double'.
EXAMPLES: GENERIC CLASS

/ A Simple Java program to show working of user defined Generic classes


// We use < > to specify Parameter type
class Test<T>
{
    // An object of type T is declared
    T obj;
    Test(T obj)
{ 
this.obj = obj; 
}  // constructor
    
public T getObject() 
{
return this.obj;
}
}
   
EXAMPLE CONTD.
class Main
{
    public static void main (String[] args)
    {
        // instance of Integer type
        Test <Integer> iObj = new Test<Integer>(15);
        System.out.println(iObj.getObject());
   
        // instance of String type
        Test <String> sObj =
                          new Test<String>("GeeksForGeeks");
        System.out.println(sObj.getObject());
    }
}
MULTIPLE TYPE PARAMETERS IN GENERIC CLASSES

We can also pass multiple Type parameters in Generic classes.


// A Simple Java program to show multiple
// type parameters in Java Generics
  
// We use < > to specify Parameter type
class Test<T, U>
{
    T obj1;  // An object of type T
    U obj2;  // An object of type U
  
    // constructor
    Test(T obj1, U obj2)
    {
        this.obj1 = obj1;
        this.obj2 = obj2;
    }
  
EXAMPLE CONTD.
// To print objects of T and U
    public void print()
    {
        System.out.println(obj1);
        System.out.println(obj2);
    }
}
  
// Driver class to test above
class Main
{
    public static void main (String[] args)
    {
        Test <String, Integer> obj =
            new Test<String, Integer>("GfG", 15);
  
        obj.print();
    }
}
GENERIC FUNCTIONS:
 We can also write generic functions that can be
called with different types of arguments based on
the type of arguments passed to generic method,
the compiler handles each method.
EXAMPLE:
// A Simple Java program to show working of user defined
// Generic functions
   
class Test
{
    // A Generic method example
    static <T> void genericDisplay (T element)
    {
        System.out.println(element.getClass().getName() +
                           " = " + element);
    }
   
  
EXAMPLE CONTD.
// Driver method
   public static void main(String[] args)
    {
         // Calling generic method with Integer argument
        genericDisplay(11);
   
        // Calling generic method with String argument
        genericDisplay("GeeksForGeeks");
   
        // Calling generic method with double argument
        genericDisplay(1.0);
    }
}
ADVANTAGES OF JAVA GENERICS

1. Code Reusability
 Generics allow us to write code that will work

with different types of data. For example,


public <T> void genericsMethod(T data) {...}

Here, we have created a generics method. This


method can be used to perform operations on
integer data, string data and so on.
ADVANTAGES CONTD.
2. Compile-time Type Checking
 The type parameter of generics provides information about the type

of data used in the generics code.


 Hence, any error can be identified at compile time which is easier to

fix than runtime errors. For example,


 // without using Generics

NormalClass list = new NormalClass(); // calls method of


NormalClass
list.display("String");
In the above code, we have a normal class. We call the method named
display() of this class by passing a string data.
 Here, the compiler does not know if the value passed in the argument

is correct or not.
ADVANTAGES CONTD.
 However, let's see what will happen if we use the generics
class instead.
 // using Generics
GenericsClass<Integer> list = new GenericsClass<>(); //
calls method of GenericsClass
list2.display("String");

In the above code, we have a generics class. Here, the type


parameter indicates that the class is working on Integer
data. Hence when the string data is passed in argument, the
compiler will generate an error.

You might also like