Generics
Generics refer to the ability to use a type as a parameter to methods and classes. This provides the ability to define a set of related classes or methods that can operate on many different types with a single declaration. This also allows type safety at compile-time allowing invalid types to be caught during compilation.
Note: Java type parameters can only be reference types, not primitive types (like int
, double
, or char
).
Generic Methods
A generic method declaration can be called with arguments of different types. The compiler handles each method call appropriately based on the types of the arguments.
Syntax
<T> void myMethod( T argument ) {
// Method body
}
The type parameter section is before the return type and is enclosed in angle brackets <...>
. Inside are one or more type parameters separated by commas (T
above) each one is an identifier for a specific type name. The identifiers can be used to declare the return type, the types of the arguments passed to the method, and as type specifiers within the method body.
Example
The following example shows how a generic method can accept arrays of different types:
public class GenericMethodExample {// Generic methodpublic static <T> void arrayPrint( T[] a ) {for(T item : a) {System.out.printf("%s",item);System.out.println();}}// Use examplepublic static void main(String args[]) {Integer[] array1 = {0,1,2,3};String[] array2 = {"Hello","World"};Character[] array3 = {'G','E','N','E','R','I','C'};arrayPrint(array1);arrayPrint(array2);arrayPrint(array3);}}
This results in the output:
0123HelloWorldGENERIC
Generic Classes
A generic class takes one or more type parameters when it is declared. One of the more familiar uses of a generic class is with Java’s various collection classes. An ArrayList
for instance is a generic class. When it is declared it requires a type parameter to specify what kind of type the ArrayList
contains. For example:
ArrayList<String> a = new ArrayList<String>();
Syntax
A generic class is defined just like a normal class, with the addition of a list of type parameters in angle brackets <...>
after the class name. The type parameters can then be used throughout the class definition to declare variables and specify parameter types for methods.
accessModifier class ClassName<T> {
// Class body
}
Example
This example creates a Bucket
class that can hold contents of various types.
This defines the generic Bucket
class:
// Bucket.javaclass Bucket<T> {private T item;public void putInBucket(T item) {this.item = item;}public T fetchFromBucket() {return item;}}
This uses the generic Bucket
class:
// UseBucket.javapublic class UseBucket {public static void main(String[] args) {Bucket<String> bucket1 = new Bucket<String>();Bucket<Integer> bucket2 = new Bucket<Integer>();bucket1.putInBucket("Hello World!");bucket2.putInBucket(12345);System.out.printf("%s",bucket1.fetchFromBucket());System.out.println();System.out.printf("%s",bucket2.fetchFromBucket());}}
This results in the output:
Hello World!12345
Contribute to Docs
- Learn more about how to get involved.
- Edit this page on GitHub to fix an error or make an improvement.
- Submit feedback to let us know how we can improve Docs.
Learn Java on Codecademy
- Career path
Computer Science
Looking for an introduction to the theory behind programming? Master Python while learning data structures, algorithms, and more!Includes 6 CoursesWith Professional CertificationBeginner Friendly75 hours - Free course
Learn Java
Learn to code in Java — a robust programming language used to create software, web and mobile apps, and more.Beginner Friendly16 hours