Generics

In the world of Java programming, generics play a crucial role in enhancing code flexibility and type safety. Generics allow developers to create classes, interfaces, and methods that can work with different types, enabling the creation of reusable and type-safe code.

Example of a Generic Class:

public class Box<T> {
private T content;

public Box(T content) {
this.content = content;
}

public T getContent() {
return content;
}
}

// Usage
Box<Integer> integerBox = new Box<>(42);
Box<String> stringBox = new Box<>(“Hello, Generics!”);

Generics are not limited to just classes. You can also use them in methods to enhance code flexibility further. Generic methods can accept different types as input arguments and return values of various types, based on the input.

Example of a Generic Method:

public class ArrayUtils {
public static <T> T getFirstElement(T[] array) {
if (array != null && array.length > 0) {
return array[0];
}
return null;
}
}

// Usage
Integer[] numbers = {1, 2, 3, 4, 5};
String[] names = {“Alice”, “Bob”, “Charlie”};

Integer firstNumber = ArrayUtils.getFirstElement(numbers);
String firstName = ArrayUtils.getFirstElement(names);

Sometimes, you may encounter situations where you want to work with a collection of objects of unknown type or with a range of types. Wildcards provide a solution for such scenarios.

Example of Wildcard Usage:

import java.util.ArrayList;
import java.util.List;

public class Shape {
// … Shape-specific code …
}

public class Circle extends Shape {
// … Circle-specific code …
}

public class Triangle extends Shape {
// … Triangle-specific code …
}

public void printShapes(List<? extends Shape> shapes) {
for (Shape shape : shapes) {
System.out.println(shape.toString());
}
}

// Usage
List<Circle> circles = new ArrayList<>();
circles.add(new Circle());

List<Triangle> triangles = new ArrayList<>();
triangles.add(new Triangle());

printShapes(circles);
printShapes(triangles);