What are the upper and lower bounds of Java function generics? how to use?

Java function generics allow setting upper and lower limits. The upper limit (extends) specifies that the data type accepted or returned by the function must be a subtype of the specified type, such as . The lower limit (super) specifies that the data type accepted or returned by the function must be the super type of the specified type, such as . The use of generics improves code reusability and security.

The upper and lower bounds of Java function generics

Function generics are a powerful mechanism that allows us to Specifies the data types that the function can handle. Generics in Java can declare upper and lower bounds to limit the data types accepted or returned by a function.

Upper Bound

The data type that the upper limit specified function can accept or return must be a subtype of a specified type. It is specified using the extends keyword. For example:

public <T extends Number> void printNumber(T number) {
   System.out.println(number);
}

This function can only accept types of Number or its subclasses (for example, Integer, Double, Float).

Lower Bound

The lower bound specifies that the data type that the function can accept or return must be a supertype of a specified type. It is specified using the super keyword. For example:

public <T super Number> void sumNumbers(List<T> numbers) {
   double sum = 0;
   for (T number : numbers) {
       sum += number.doubleValue();
   }
}

This function can accept a Number or a list of its supertypes, such as List

Practical case

Suppose we have a function that compares two numbers:

public static <T extends Comparable<T>> int compare(T obj1, T obj2) {
    return obj1.compareTo(obj2);
}

We can use this function to compare any object that implements the Comparable interface Types, for example:

int result = compare(10, 20); // result 为 -1

Usage methods

When using upper and lower bounds for generics, please remember the following:

• The upper limit specifies that the data types that the function can handle must be subtypes of the specified type.
• The lower limit specifies that the data type that the function can handle must be a supertype of the specified type.
• You can use both upper and lower bounds to further limit the data types accepted or returned by the function.
• The use of generics can improve code reusability and security.

The above is the detailed content of What are the upper and lower bounds of Java function generics? how to use?. For more information, please follow other related articles on the PHP Chinese website!