MACRO NEPAL
Bounded Type Parameters in Java
awiskar acharya
October 30, 2025
9:46 am

Bounded type parameters restrict the types that can be used as generic type arguments. They allow you to specify that a type parameter must be a subtype of certain classes or implement certain interfaces.

1. Upper Bounded Type Parameters

Basic Upper Bound Syntax

import java.util.*;
public class UpperBoundBasics {
// Upper bounded type parameter - T must be Number or its subclass
public static <T extends Number> double sumOfList(List<T> list) {
double sum = 0.0;
for (T number : list) {
sum += number.doubleValue(); // Can call Number methods
}
return sum;
}
// Multiple bounds - T must implement both Comparable and Serializable
public static <T extends Comparable<T> & Serializable> T findMax(T[] array) {
if (array == null || array.length == 0) return null;
T max = array[0];
for (T element : array) {
if (element.compareTo(max) > 0) {
max = element;
}
}
return max;
}
// Upper bound with wildcards
public static double sumOfNumbers(List<? extends Number> list) {
double sum = 0.0;
for (Number number : list) {
sum += number.doubleValue();
}
return sum;
}
public static void main(String[] args) {
System.out.println("=== Upper Bounded Type Parameters ===");
// Test with Integer list (Integer extends Number)
List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
System.out.println("Sum of integers: " + sumOfList(integers));
// Test with Double list (Double extends Number)
List<Double> doubles = Arrays.asList(1.1, 2.2, 3.3);
System.out.println("Sum of doubles: " + sumOfList(doubles));
// Test with wildcard method
System.out.println("Sum using wildcard: " + sumOfNumbers(integers));
System.out.println("Sum using wildcard: " + sumOfNumbers(doubles));
// Multiple bounds example
String[] names = {"Alice", "Bob", "Charlie"};
String maxName = findMax(names);
System.out.println("Max name: " + maxName);
demonstrateClassHierarchy();
}
public static void demonstrateClassHierarchy() {
System.out.println("\n=== Class Hierarchy with Bounds ===");
class Animal {
String name;
Animal(String name) { this.name = name; }
void eat() { System.out.println(name + " is eating"); }
}
class Mammal extends Animal {
Mammal(String name) { super(name); }
void walk() { System.out.println(name + " is walking"); }
}
class Dog extends Mammal {
Dog(String name) { super(name); }
void bark() { System.out.println(name + " is barking"); }
}
class Cat extends Mammal {
Cat(String name) { super(name); }
void meow() { System.out.println(name + " is meowing"); }
}
// Generic method with upper bound
public static <T extends Mammal> void performMammalActions(List<T> mammals) {
for (T mammal : mammals) {
mammal.eat();    // From Animal
mammal.walk();   // From Mammal
// mammal.bark(); // Compile error - not all mammals can bark
}
}
List<Dog> dogs = Arrays.asList(new Dog("Buddy"), new Dog("Max"));
List<Cat> cats = Arrays.asList(new Cat("Whiskers"), new Cat("Fluffy"));
System.out.println("Dog actions:");
performMammalActions(dogs);
System.out.println("\nCat actions:");
performMammalActions(cats);
}
}

Upper Bounds with Custom Classes

import java.util.*;
public class UpperBoundCustomClasses {
// Custom hierarchy for demonstration
static abstract class Shape implements Comparable<Shape> {
protected String name;
protected double area;
public Shape(String name, double area) {
this.name = name;
this.area = area;
}
public abstract void draw();
@Override
public int compareTo(Shape other) {
return Double.compare(this.area, other.area);
}
@Override
public String toString() {
return String.format("%s (area: %.2f)", name, area);
}
}
static class Circle extends Shape {
private double radius;
public Circle(String name, double radius) {
super(name, Math.PI * radius * radius);
this.radius = radius;
}
@Override
public void draw() {
System.out.println("Drawing circle: " + name + " with radius " + radius);
}
}
static class Rectangle extends Shape {
private double width, height;
public Rectangle(String name, double width, double height) {
super(name, width * height);
this.width = width;
this.height = height;
}
@Override
public void draw() {
System.out.println("Drawing rectangle: " + name + " " + width + "x" + height);
}
}
static class Triangle extends Shape {
private double base, height;
public Triangle(String name, double base, double height) {
super(name, 0.5 * base * height);
this.base = base;
this.height = height;
}
@Override
public void draw() {
System.out.println("Drawing triangle: " + name + " base=" + base + " height=" + height);
}
}
// Generic methods with upper bounds
public static <T extends Shape> void drawAllShapes(List<T> shapes) {
for (T shape : shapes) {
shape.draw();
}
}
public static <T extends Shape> T findLargestShape(List<T> shapes) {
if (shapes.isEmpty()) return null;
T largest = shapes.get(0);
for (T shape : shapes) {
if (shape.compareTo(largest) > 0) {
largest = shape;
}
}
return largest;
}
public static <T extends Shape & Comparable<Shape>> void sortShapes(List<T> shapes) {
Collections.sort(shapes);
}
// Wildcard version
public static void processShapes(List<? extends Shape> shapes) {
for (Shape shape : shapes) {
System.out.println("Processing: " + shape);
}
}
public static void main(String[] args) {
System.out.println("=== Upper Bounds with Custom Classes ===");
List<Circle> circles = Arrays.asList(
new Circle("Small Circle", 5.0),
new Circle("Large Circle", 15.0)
);
List<Rectangle> rectangles = Arrays.asList(
new Rectangle("Small Rect", 4.0, 3.0),
new Rectangle("Large Rect", 10.0, 8.0)
);
List<Triangle> triangles = Arrays.asList(
new Triangle("Small Triangle", 3.0, 4.0),
new Triangle("Large Triangle", 6.0, 8.0)
);
// Draw all shapes
System.out.println("Drawing circles:");
drawAllShapes(circles);
System.out.println("\nDrawing rectangles:");
drawAllShapes(rectangles);
// Find largest shapes
System.out.println("\nLargest circle: " + findLargestShape(circles));
System.out.println("Largest rectangle: " + findLargestShape(rectangles));
// Process shapes using wildcard
System.out.println("\nProcessing circles:");
processShapes(circles);
System.out.println("\nProcessing triangles:");
processShapes(triangles);
// Sort and display
List<Shape> mixedShapes = new ArrayList<>();
mixedShapes.add(new Circle("Medium Circle", 10.0));
mixedShapes.add(new Rectangle("Medium Rect", 6.0, 8.0));
mixedShapes.add(new Triangle("Medium Triangle", 5.0, 12.0));
System.out.println("\nBefore sorting:");
mixedShapes.forEach(System.out::println);
Collections.sort(mixedShapes);
System.out.println("\nAfter sorting by area:");
mixedShapes.forEach(System.out::println);
}
}

2. Lower Bounded Type Parameters

Lower Bound Syntax and Usage

import java.util.*;
public class LowerBoundExamples {
// Lower bounded wildcard - can accept List<Integer>, List<Number>, List<Object>
public static void addNumbers(List<? super Integer> list) {
for (int i = 1; i <= 5; i++) {
list.add(i); // Can add Integer to any supertype of Integer
}
}
// Lower bound in generic method
public static <T> void copy(List<? super T> dest, List<? extends T> src) {
for (T element : src) {
dest.add(element);
}
}
// Multiple operations with lower bounds
public static <T> void addAll(List<? super T> destination, T... elements) {
for (T element : elements) {
destination.add(element);
}
}
public static void main(String[] args) {
System.out.println("=== Lower Bounded Type Parameters ===");
// Test with different list types
List<Integer> integerList = new ArrayList<>();
addNumbers(integerList);
System.out.println("Integer list: " + integerList);
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);
// Copy operation demonstration
demonstrateCopyOperation();
// PECS principle demonstration
demonstratePECSPrinciple();
}
public static void demonstrateCopyOperation() {
System.out.println("\n=== Copy Operation with Bounds ===");
// Source list (producer - uses extends)
List<Integer> source = Arrays.asList(1, 2, 3, 4, 5);
// Destination lists (consumer - uses super)
List<Integer> intDest = new ArrayList<>();
List<Number> numDest = new ArrayList<>();
List<Object> objDest = new ArrayList<>();
// Copy from source to different destinations
copy(intDest, source);
copy(numDest, source);
copy(objDest, source);
System.out.println("Source: " + source);
System.out.println("Integer destination: " + intDest);
System.out.println("Number destination: " + numDest);
System.out.println("Object destination: " + objDest);
}
public static void demonstratePECSPrinciple() {
System.out.println("\n=== PECS Principle (Producer Extends, Consumer Super) ===");
class Fruit {
String name;
Fruit(String name) { this.name = name; }
@Override public String toString() { return name; }
}
class Apple extends Fruit {
Apple(String name) { super(name); }
}
class Banana extends Fruit {
Banana(String name) { super(name); }
}
// Producer - read only (uses extends)
List<Apple> apples = Arrays.asList(new Apple("Red Apple"), new Apple("Green Apple"));
List<? extends Fruit> fruitBasket = apples; // Can read as Fruit
System.out.println("Reading from producer:");
for (Fruit fruit : fruitBasket) {
System.out.println(" - " + fruit);
}
// Consumer - write only (uses super)
List<Fruit> fruitBowl = new ArrayList<>();
List<? super Apple> appleSink = fruitBowl; // Can write Apples
appleSink.add(new Apple("Fuji Apple"));
appleSink.add(new Apple("Gala Apple"));
// appleSink.add(new Fruit("Generic Fruit")); // Compile error!
System.out.println("Consumer contains: " + fruitBowl);
}
}

3. Multiple Bounds

Multiple Bounds Syntax

import java.util.*;
import java.io.Serializable;
import java.time.LocalDateTime;
public class MultipleBounds {
// Interface definitions
interface Identifiable {
String getId();
void setId(String id);
}
interface Timestamped {
LocalDateTime getCreatedAt();
void setCreatedAt(LocalDateTime time);
}
interface Auditable extends Serializable {
String getCreatedBy();
void setCreatedBy(String user);
}
// Class implementing multiple interfaces
static class Document implements Identifiable, Timestamped, Auditable {
private String id;
private String content;
private LocalDateTime createdAt;
private String createdBy;
public Document(String id, String content, String createdBy) {
this.id = id;
this.content = content;
this.createdAt = LocalDateTime.now();
this.createdBy = createdBy;
}
@Override public String getId() { return id; }
@Override public void setId(String id) { this.id = id; }
@Override public LocalDateTime getCreatedAt() { return createdAt; }
@Override public void setCreatedAt(LocalDateTime time) { this.createdAt = time; }
@Override public String getCreatedBy() { return createdBy; }
@Override public void setCreatedBy(String user) { this.createdBy = user; }
@Override
public String toString() {
return String.format("Document{id='%s', content='%s', createdBy='%s', at=%s}", 
id, content, createdBy, createdAt);
}
}
static class Product implements Identifiable, Serializable {
private String id;
private String name;
private double price;
public Product(String id, String name, double price) {
this.id = id;
this.name = name;
this.price = price;
}
@Override public String getId() { return id; }
@Override public void setId(String id) { this.id = id; }
@Override
public String toString() {
return String.format("Product{id='%s', name='%s', price=%.2f}", id, name, price);
}
}
// Generic methods with multiple bounds
public static <T extends Identifiable & Serializable> void saveToDatabase(T entity) {
System.out.println("Saving to database: " + entity.getId());
// Serialization and database logic would go here
}
public static <T extends Identifiable & Timestamped & Auditable> void auditEntity(T entity) {
System.out.printf("Audit: %s created by %s at %s%n",
entity.getId(), entity.getCreatedBy(), entity.getCreatedAt());
}
public static <T extends Comparable<T> & Serializable> T findMax(T[] array) {
if (array == null || array.length == 0) return null;
T max = array[0];
for (T element : array) {
if (element.compareTo(max) > 0) {
max = element;
}
}
return max;
}
// Multiple bounds with class and interfaces
public static <T extends Number & Comparable<T> & Serializable> 
void processNumber(T number) {
System.out.println("Processing number: " + number);
System.out.println("Double value: " + number.doubleValue());
}
public static void main(String[] args) {
System.out.println("=== Multiple Bounds ===");
// Test with Document (implements all interfaces)
Document doc = new Document("DOC-001", "Important content", "john_doe");
auditEntity(doc);
saveToDatabase(doc);
// Test with Product (implements Identifiable & Serializable)
Product product = new Product("PROD-001", "Laptop", 999.99);
saveToDatabase(product);
// auditEntity(product); // Compile error - Product doesn't implement Timestamped & Auditable
// Test with numbers
Integer[] numbers = {5, 2, 8, 1, 9};
Integer maxNumber = findMax(numbers);
System.out.println("Max number: " + maxNumber);
processNumber(42);
processNumber(3.14);
demonstrateComplexBounds();
}
public static void demonstrateComplexBounds() {
System.out.println("\n=== Complex Multiple Bounds ===");
abstract class Entity implements Comparable<Entity>, Serializable {
protected String id;
public Entity(String id) {
this.id = id;
}
public String getId() { return id; }
@Override
public int compareTo(Entity other) {
return this.id.compareTo(other.id);
}
@Override
public abstract String toString();
}
class User extends Entity {
private String username;
public User(String id, String username) {
super(id);
this.username = username;
}
@Override
public String toString() {
return String.format("User{id='%s', username='%s'}", id, username);
}
}
class Order extends Entity {
private double amount;
public Order(String id, double amount) {
super(id);
this.amount = amount;
}
@Override
public String toString() {
return String.format("Order{id='%s', amount=%.2f}", id, amount);
}
}
// Method with complex bounds
public static <T extends Entity & Comparable<Entity> & Serializable> 
void processEntity(T entity) {
System.out.println("Processing entity: " + entity);
System.out.println("Entity ID: " + entity.getId());
}
User user = new User("USR-001", "alice");
Order order = new Order("ORD-001", 199.99);
processEntity(user);
processEntity(order);
// Collection with bounded wildcard
List<? extends Entity> entities = Arrays.asList(user, order);
System.out.println("\nAll entities:");
for (Entity entity : entities) {
System.out.println(" - " + entity);
}
}
}

4. Bounded Type Parameters in Generic Classes

Generic Classes with Bounds

import java.util.*;
import java.time.LocalDateTime;
public class BoundedGenericClasses {
// Generic class with upper bound
static class NumberContainer<T extends Number> {
private T number;
public NumberContainer(T number) {
this.number = number;
}
public T getNumber() {
return number;
}
public void setNumber(T number) {
this.number = number;
}
public double getDoubleValue() {
return number.doubleValue();
}
public int getIntValue() {
return number.intValue();
}
@Override
public String toString() {
return String.format("NumberContainer{value=%s, double=%.2f, int=%d}", 
number, getDoubleValue(), getIntValue());
}
}
// Generic class with multiple bounds
static class AuditableContainer<T extends Comparable<T> & Serializable> {
private T value;
private LocalDateTime createdAt;
private String createdBy;
public AuditableContainer(T value, String createdBy) {
this.value = value;
this.createdAt = LocalDateTime.now();
this.createdBy = createdBy;
}
public T getValue() { return value; }
public LocalDateTime getCreatedAt() { return createdAt; }
public String getCreatedBy() { return createdBy; }
public boolean isGreaterThan(T other) {
return value.compareTo(other) > 0;
}
@Override
public String toString() {
return String.format("AuditableContainer{value=%s, createdBy='%s', at=%s}", 
value, createdBy, createdAt);
}
}
// Generic class with lower bound (less common, usually used in methods)
static class ConsumerContainer<T> {
private List<? super T> items;
public ConsumerContainer() {
this.items = new ArrayList<>();
}
public void addItem(T item) {
items.add(item);
}
@SuppressWarnings("unchecked")
public T getItem(int index) {
// Need to cast since we only know it's supertype of T
return (T) items.get(index);
}
public int size() {
return items.size();
}
@Override
public String toString() {
return "ConsumerContainer{items=" + items + "}";
}
}
public static void main(String[] args) {
System.out.println("=== Bounded Type Parameters in Generic Classes ===");
// NumberContainer examples
NumberContainer<Integer> intContainer = new NumberContainer<>(42);
NumberContainer<Double> doubleContainer = new NumberContainer<>(3.14159);
// NumberContainer<String> stringContainer = new NumberContainer<>("hello"); // Compile error!
System.out.println("Integer container: " + intContainer);
System.out.println("Double container: " + doubleContainer);
// AuditableContainer examples
AuditableContainer<String> stringContainer = 
new AuditableContainer<>("Important Data", "admin");
AuditableContainer<Integer> integerContainer = 
new AuditableContainer<>(100, "system");
System.out.println("\nString container: " + stringContainer);
System.out.println("Integer container: " + integerContainer);
System.out.println("Is 100 > 50? " + integerContainer.isGreaterThan(50));
// ConsumerContainer examples
ConsumerContainer<Integer> consumer = new ConsumerContainer<>();
consumer.addItem(1);
consumer.addItem(2);
consumer.addItem(3);
System.out.println("\nConsumer container: " + consumer);
System.out.println("Item at index 1: " + consumer.getItem(1));
demonstrateAdvancedGenericClass();
}
public static void demonstrateAdvancedGenericClass() {
System.out.println("\n=== Advanced Generic Class with Bounds ===");
interface Validatable {
boolean isValid();
}
interface Persistable {
String getStorageKey();
}
class DataEntity implements Validatable, Persistable, Comparable<DataEntity> {
private String id;
private String data;
public DataEntity(String id, String data) {
this.id = id;
this.data = data;
}
@Override
public boolean isValid() {
return id != null && !id.trim().isEmpty() && 
data != null && !data.trim().isEmpty();
}
@Override
public String getStorageKey() {
return "entity_" + id;
}
@Override
public int compareTo(DataEntity other) {
return this.id.compareTo(other.id);
}
@Override
public String toString() {
return String.format("DataEntity{id='%s', data='%s', valid=%b}", 
id, data, isValid());
}
}
// Generic repository with multiple bounds
class Repository<T extends Validatable & Persistable & Comparable<T>> {
private Map<String, T> storage = new HashMap<>();
public void save(T entity) {
if (entity.isValid()) {
storage.put(entity.getStorageKey(), entity);
System.out.println("Saved: " + entity);
} else {
System.out.println("Cannot save invalid entity: " + entity);
}
}
public T findById(String key) {
return storage.get(key);
}
public List<T> findAllSorted() {
List<T> entities = new ArrayList<>(storage.values());
Collections.sort(entities);
return entities;
}
public int size() {
return storage.size();
}
}
Repository<DataEntity> repo = new Repository<>();
DataEntity validEntity = new DataEntity("001", "Valid data");
DataEntity invalidEntity = new DataEntity("", "Invalid data");
DataEntity anotherValid = new DataEntity("002", "More data");
repo.save(validEntity);
repo.save(invalidEntity); // Won't be saved
repo.save(anotherValid);
System.out.println("\nAll sorted entities:");
repo.findAllSorted().forEach(System.out::println);
System.out.println("Repository size: " + repo.size());
}
}

5. Real-World Examples

Data Validation Framework

import java.util.*;
import java.time.LocalDate;
import java.time.Period;
public class ValidationFramework {
// Validation interfaces
interface Validatable {
boolean isValid();
List<String> getValidationErrors();
}
interface Auditable {
String getCreatedBy();
LocalDate getCreatedDate();
String getLastModifiedBy();
LocalDate getLastModifiedDate();
}
interface BusinessEntity extends Validatable, Auditable {
String getId();
String getName();
}
// Concrete entity classes
static class Customer implements BusinessEntity {
private String id;
private String name;
private String email;
private LocalDate birthDate;
private String createdBy;
private LocalDate createdDate;
public Customer(String id, String name, String email, LocalDate birthDate, String createdBy) {
this.id = id;
this.name = name;
this.email = email;
this.birthDate = birthDate;
this.createdBy = createdBy;
this.createdDate = LocalDate.now();
}
@Override public String getId() { return id; }
@Override public String getName() { return name; }
public String getEmail() { return email; }
public LocalDate getBirthDate() { return birthDate; }
@Override public String getCreatedBy() { return createdBy; }
@Override public LocalDate getCreatedDate() { return createdDate; }
@Override public String getLastModifiedBy() { return createdBy; }
@Override public LocalDate getLastModifiedDate() { return createdDate; }
@Override
public boolean isValid() {
return getValidationErrors().isEmpty();
}
@Override
public List<String> getValidationErrors() {
List<String> errors = new ArrayList<>();
if (id == null || id.trim().isEmpty()) {
errors.add("ID is required");
}
if (name == null || name.trim().isEmpty()) {
errors.add("Name is required");
}
if (email == null || !email.contains("@")) {
errors.add("Valid email is required");
}
if (birthDate != null) {
int age = Period.between(birthDate, LocalDate.now()).getYears();
if (age < 18) {
errors.add("Customer must be at least 18 years old");
}
}
return errors;
}
@Override
public String toString() {
return String.format("Customer{id='%s', name='%s', email='%s', valid=%b}", 
id, name, email, isValid());
}
}
static class Product implements BusinessEntity {
private String id;
private String name;
private double price;
private int stock;
private String createdBy;
private LocalDate createdDate;
public Product(String id, String name, double price, int stock, String createdBy) {
this.id = id;
this.name = name;
this.price = price;
this.stock = stock;
this.createdBy = createdBy;
this.createdDate = LocalDate.now();
}
@Override public String getId() { return id; }
@Override public String getName() { return name; }
public double getPrice() { return price; }
public int getStock() { return stock; }
@Override public String getCreatedBy() { return createdBy; }
@Override public LocalDate getCreatedDate() { return createdDate; }
@Override public String getLastModifiedBy() { return createdBy; }
@Override public LocalDate getLastModifiedDate() { return createdDate; }
@Override
public boolean isValid() {
return getValidationErrors().isEmpty();
}
@Override
public List<String> getValidationErrors() {
List<String> errors = new ArrayList<>();
if (id == null || id.trim().isEmpty()) {
errors.add("Product ID is required");
}
if (name == null || name.trim().isEmpty()) {
errors.add("Product name is required");
}
if (price < 0) {
errors.add("Price cannot be negative");
}
if (stock < 0) {
errors.add("Stock cannot be negative");
}
return errors;
}
@Override
public String toString() {
return String.format("Product{id='%s', name='%s', price=%.2f, stock=%d, valid=%b}", 
id, name, price, stock, isValid());
}
}
// Generic validation service with bounded type parameters
static class ValidationService<T extends BusinessEntity> {
public ValidationResult validate(T entity) {
List<String> errors = entity.getValidationErrors();
boolean isValid = errors.isEmpty();
return new ValidationResult(entity, isValid, errors);
}
public List<ValidationResult> validateAll(List<T> entities) {
List<ValidationResult> results = new ArrayList<>();
for (T entity : entities) {
results.add(validate(entity));
}
return results;
}
public <U extends T> void processValidEntities(List<U> entities, EntityProcessor<U> processor) {
for (U entity : entities) {
if (entity.isValid()) {
processor.process(entity);
} else {
System.out.println("Skipping invalid entity: " + entity);
}
}
}
}
// Support classes
static class ValidationResult {
private final BusinessEntity entity;
private final boolean valid;
private final List<String> errors;
public ValidationResult(BusinessEntity entity, boolean valid, List<String> errors) {
this.entity = entity;
this.valid = valid;
this.errors = errors;
}
public BusinessEntity getEntity() { return entity; }
public boolean isValid() { return valid; }
public List<String> getErrors() { return errors; }
@Override
public String toString() {
return String.format("ValidationResult{entity=%s, valid=%b, errors=%s}", 
entity, valid, errors);
}
}
interface EntityProcessor<T extends BusinessEntity> {
void process(T entity);
}
public static void main(String[] args) {
System.out.println("=== Data Validation Framework ===");
// Create sample data
Customer validCustomer = new Customer("CUST001", "John Doe", "[email protected]", 
LocalDate.of(1990, 1, 1), "admin");
Customer invalidCustomer = new Customer("", "Jane Smith", "invalid-email", 
LocalDate.of(2010, 1, 1), "admin");
Product validProduct = new Product("PROD001", "Laptop", 999.99, 10, "admin");
Product invalidProduct = new Product("", "", -10, -5, "admin");
// Validate customers
ValidationService<Customer> customerService = new ValidationService<>();
System.out.println("Customer validation:");
System.out.println(customerService.validate(validCustomer));
System.out.println(customerService.validate(invalidCustomer));
// Validate products
ValidationService<Product> productService = new ValidationService<>();
System.out.println("\nProduct validation:");
System.out.println(productService.validate(validProduct));
System.out.println(productService.validate(invalidProduct));
// Process valid entities
List<Customer> customers = Arrays.asList(validCustomer, invalidCustomer);
System.out.println("\nProcessing valid customers:");
customerService.processValidEntities(customers, 
customer -> System.out.println("Processing: " + customer.getName()));
// Batch validation
List<Product> products = Arrays.asList(validProduct, invalidProduct);
List<ValidationResult> productResults = productService.validateAll(products);
System.out.println("\nBatch product validation results:");
productResults.forEach(System.out::println);
}
}

Summary

Key Concepts:

  1. Upper Bounds (extends):
  • Restrict type parameter to be a subtype of specific class/interface
  • <T extends Number> - T must be Number or subclass
  • Allows access to methods of the bound type
  1. Lower Bounds (super):
  • Restrict type parameter to be a supertype of specific class
  • <? super Integer> - Can be Integer, Number, or Object
  • Used for write operations (PECS principle)
  1. Multiple Bounds:
  • <T extends ClassA & InterfaceB & InterfaceC>
  • Class must come first, then interfaces
  • Type must satisfy all bounds
  1. Wildcard Bounds:
  • <? extends T> - Upper bounded wildcard (producer)
  • <? super T> - Lower bounded wildcard (consumer)

Best Practices:

  1. Use upper bounds when you need to call specific methods
  2. Use PECS principle: Producer Extends, Consumer Super
  3. Prefer wildcards for more flexibility in method parameters
  4. Use multiple bounds for complex constraints
  5. Keep bounds minimal - only specify what's actually needed

Common Use Cases:

  1. Collections framework - sorting, copying with bounds
  2. Validation frameworks - entities with multiple interfaces
  3. Repository patterns - generic DAOs with constraints
  4. Utility methods - working with number types, comparable objects
  5. API design - enforcing contracts through bounds

Bounded type parameters provide type safety while maintaining flexibility in generic programming, making them essential for robust Java applications.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper