Java Generics Lower Bounded Wildcards Example

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

✅ Some premium posts are free to read — no account needed. Follow me on Medium to stay updated and support my writing.

🎓 Top 10 Udemy Courses (Huge Discount): Explore My Udemy Courses — Learn through real-time, project-based development.

▶️ Subscribe to My YouTube Channel (172K+ subscribers): Java Guides on YouTube

Introduction

Lower bounded wildcards in Java Generics restrict the unknown type to be a specific type or a supertype of that type. This is useful when you want to add elements to a collection and ensure that the elements are of a certain type or its supertype. Lower bounded wildcards are declared using the super keyword.

Table of Contents

1. What are Lower Bounded Wildcards?
2. Syntax of Lower Bounded Wildcards
3. Example: Lower Bounded Wildcards
4. Explanation of the Example
5. Use Cases for Lower Bounded Wildcards
6. Conclusion

1. What are Lower Bounded Wildcards?

Lower bounded wildcards allow you to specify that a type parameter must be a specific type or a supertype of that type. This ensures type safety and allows you to add elements to a collection that can accept the specified type or its supertype.

2. Syntax of Lower Bounded Wildcards

The syntax for lower bounded wildcards is to use the super keyword followed by the lower bound type within angle brackets (<>).

Syntax:

List<? super Type> list = new ArrayList<>();

3. Example: Lower Bounded Wildcards

Example:

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

public class LowerBoundedWildcardExample {
    // Method to add numbers to a list
    public static void addNumbers(List<? super Integer> list) {
        for (int i = 1; i <= 5; i++) {
            list.add(i);
        }
    }

    public static void main(String[] args) {
        List<Number> numberList = new ArrayList<>();
        addNumbers(numberList);

        System.out.println("Number List: " + numberList);

        List<Object> objectList = new ArrayList<>();
        addNumbers(objectList);

        System.out.println("Object List: " + objectList);
    }
}

Output:

Number List: [1, 2, 3, 4, 5]
Object List: [1, 2, 3, 4, 5]

4. Explanation of the Example

• Method Definition: The addNumbers method accepts a list of any type that is a supertype of Integer. This means the list can contain Integer, Number, Object, etc.
• Adding Elements: The method adds integers 1 through 5 to the list.
• Usage: In the main method, two lists (numberList and objectList) are created and populated with integers using the addNumbers method. The output shows that both lists have been correctly populated with the integers.

5. Use Cases for Lower Bounded Wildcards

• Writing to a Collection: When you want to add elements to a collection, using a lower bounded wildcard ensures that the collection can accept the specified type or its supertype.
• Generic Algorithms: Lower bounded wildcards are useful in generic algorithms that need to add elements to a collection.
• Type Safety: They help ensure type safety by restricting the types that can be used as arguments, preventing potential runtime errors.

6. Conclusion

Lower bounded wildcards in Java Generics provide a powerful way to write flexible and type-safe code. By specifying that a type parameter must be a specific type or a supertype of that type, you can ensure that your methods can safely add elements to a collection. Understanding and using lower bounded wildcards can enhance the robustness and reusability of your Java programs.

Happy coding!