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 7bac7e57b1a28a76cdacdabd991c2663. 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 8991fee22ef165e6bc8a2922b920a06c. 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 Lista87fdacec66f0909fc0757c19f2d2b1d or Listc0f559cc8d56b43654fcbe4aa9df7b4a.

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!