7. Generics
7.1. What is Generic
Brief Explanation:Generics in Java allow you to create classes and methods that can work with different data types while maintaining type safety. They provide a way to parameterize the types used in a class or method, making the code more flexible and reusable.
Programming Example
Without generics:
Class Box {
Private Object content;
Public void setContent(Object content) {
This.content = content;
}
Public Object getContent() {
Return content;
}
}
Public class Main {
Public static void main(String[] args) {
Box box = new Box();
Box.setContent(“Hello, Generics!”); // Storing a String
String message = (String) box.getContent(); // Need to cast to String
System.out.println(message);
}
}
With generics:
Class Box<T> {
Private T content;
Public void setContent(T content) {
This.content = content;
}
Public T getContent() {
Return content;
}
}
Public class Main {
Public static void main(String[] args) {
Box<String> box = new Box<>(); // Specifying the type as String
Box.setContent(“Hello, Generics!”); // Storing a String
String message = box.getContent(); // No need to cast, already a String
System.out.println(message);
}
}
```
7.2. Generic Class
Brief Explanation:
A generic class is a class that can work with multiple types. It is defined with one or more type parameters specified in angle brackets (`<>`). These type parameters act as placeholders for the actual types that will be used when creating an instance of the class.
Programming examples
// Generic class: Box
Class Box<T> {
Private T content;
Public void setContent(T content) {
This.content = content;
}
Public T getContent() {
Return content;
}
}
Public class Main {
Public static void main(String[] args) {
Box<Integer> intBox = new Box<>();
intBox.setContent(42); // Storing an Integer
int number = intBox.getContent(); // No need to cast, already an Integer
Box<String> stringBox = new Box<>();
stringBox.setContent(“Java Generics”); // Storing a String
String message = stringBox.getContent(); // No need to cast, already a String
System.out.println(“Number: “ + number);
System.out.println(“Message: “ + message);
}
}
```
7.3. Generic Method
A generic method is a method that can work with different types. It is defined with its own type parameters, separate from the class’s type parameters. Generic methods are particularly useful when the method needs to deal with types that are unrelated to the class’s generic type.
Programming examples
// Generic class: Pair
Class Pair<T, U> {
Private T first;
Private U second;
Public Pair(T first, U second) {
This.first = first;
This.second = second;
}
Public T getFirst() {
Return first;
}
Public U getSecond() {
Return second;
}
}
Public class Main {
// Generic method: printPair
Public static <T, U> void printPair(Pair<T, U> pair) {
T first = pair.getFirst();
U second = pair.getSecond();
System.out.println(“First: “ + first + “, Second: “ + second);
}
Public static void main(String[] args) {
Pair<Integer, String> pair1 = new Pair<>(42, “Java”);
Pair<String, Double> pair2 = new Pair<>(“Generics”, 3.14);
printPair(pair1);
printPair(pair2);
}
}
In this example, we have a generic class `Pair` that can hold two different types (`T` and `U`). Additionally, we have a generic method `printPair` that can work with different types of `
Comments
Post a Comment