What does <T extends mean?

I have seen a method like shown below:

protected <T extends ABC> T save( T Acd, boolean en) {

What does it do? What is these type of method declarations called in Java?

It is called a generic method. This whole concept is called "Generics" in Java. That declaration means T can be any type that is subclass of ABC.

Bounded Type Parameters:

There may be times when you'll want to restrict the kinds of types that are allowed to be passed to a type parameter. For example, a method that operates on numbers might only want to accept instances of Number or its subclasses. This is what bounded type parameters are for.

To declare a bounded type parameter, list the type parameter's name, followed by the extends keyword, followed by its upper bound. Example:

Following example illustrate how extends is used in a general sense to mean either "extends" (as in classes) or "implements" (as in interfaces). This example is Generic method to return the largest of three Comparable objects:

public class MaximumTest
{
   // determines the largest of three Comparable objects
   public static <T extends Comparable<T>> T maximum(T x, T y, T z)
   {                      
      T max = x; // assume x is initially the largest       
      if ( y.compareTo( max ) > 0 ){
         max = y; // y is the largest so far
      }
      if ( z.compareTo( max ) > 0 ){
         max = z; // z is the largest now                 
      }
      return max; // returns the largest object   
   }
   public static void main( String args[] )
   {
      System.out.printf( "Max of %d, %d and %d is %d\n\n", 
                   3, 4, 5, maximum( 3, 4, 5 ) );

       System.out.printf( "Maxm of %.1f,%.1f and %.1f is %.1f\n\n",
                   6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ) );

       System.out.printf( "Max of %s, %s and %s is %s\n","pear",
         "apple", "orange", maximum( "pear", "apple", "orange" ) );
   }
}

This is a generic save method which excepts parameter T and boolean type where T must be upper bounded by ABC Class. ABC class or any subclass will be accepted.

protected <T extends ABC> T save( T Acd, boolean en) {
    // ...
}

In this function, there are two places we should pay attention to

• bounded type parameter: <T extends ABC>
• returned-type: T

Based on those, I can answer your questions as following > What does it do?

save() is a generic method that returns a value of type T. T is a generic type, that is restricted to ABC. The scope of T is limited to save().

> What is these type of method declarations called in Java?

IMO, the answer should be bounded type parameters, instead of generics. More about generics in Java, you can find here.

One more question I would like to add by myself: Why do we want such thing? > There may be times when you want to restrict the types that can be used as type arguments in a parameterized type. For example, a method that operates on numbers might only want to accept instances of Number or its subclasses. This is what bounded type parameters are for [1].

It means that you must send an ABC object or a child of ABC, no other classes allowed. Also, your Acd variable could use the methods in ABC class that are visible to the class that contians the save method.

This is useful when your T class extends interfaces. For example, you're creating a class that handles object array sorting and this class must implement tne Comparable interface, otherwise the array won't be allowed:

class Class1 implements Comparable<Class1> {
    //attributes, getters and setters...
    int x;

    //implementing the interface...
    public int compareTo(Class1 c1) {
        //nice implementation of compareTo
        return (this.x > c1.x)? 1 : (this.x < c1.x) ? 0 : -1;
    }
}

class Class2 {
    int x;
}

public class Sorter<T extends Comparable<T>> {

    public static void insertionSort(T[] array) {
        //good implementation of insertion sort goes here...
        //just to prove that you can use the methods of the Comparable interface...
        array[0].compareTo(array[1]);
    }

    public static void main(String[] args) {
        Class1[] arrC1 = new Class1[5];
        Class2[] arrC2 = new Class2[5];
        //fill the arrays...
        insertionSort(arrC1); //good!
        insertionSort(arrC2); //compiler error!
    }
}

This are generics. Generics with Type Bounds!

See here for refernce

This is called generics in Java.

Official explanation:

> In a nutshell, generics enable types (classes and interfaces) to be parameters when defining classes, interfaces and methods. Much like the more familiar formal parameters used in method declarations, type parameters provide a way for you to re-use the same code with different inputs. The difference is that the inputs to formal parameters are values, while the inputs to type parameters are types.

Informally:

Strongly typed languages like Java cause more errors show up at compile time instead of runtime. This is a good thing. But it causes code duplication. To mitigate this generics was added to Java.