Q: Java generic method parameter type inside brackets vs. outside brackets Is there any difference between:
static void findMax(LinkedList<? extends Number> list){...}

and:
static <T extends Number> void findMax(LinkedList<T> list){...}

Since both work, I'd like to know if there's any big difference between the two and which is advised.

A: Here's the difference
static void findMax(LinkedList<? extends Number> list){
    list.add(list.get(0));  <-- compile error
}

you cannot add anything but null to the list. 
At the same time this compiles with no error or warning
static <T extends Number> void findMax2(LinkedList<T> list){
    list.add(list.get(0));  <-- no error
}


A: In terms of power of the signature, both are exactly identical. What I mean is if you have any API that uses the second signature, you can replace it with an API that uses the first signature, and any code that used the API would work exactly as before, and any code that didn't work before would also not work. So to the outside code, there is no difference between the two.
How would you change the implementation of the second one to the first one? Other people have pointed out examples with list.add(list.get(0));. Can an API with the first signature perform that action? Yes. It's very simple. Just have the first one call the second one (make the second one into an internal private method). This is called a capture helper. The fact you can do this proves that both can "do" the same things ("do" as in through whatever internal means, including call other methods) from the perspective of outside code.
static void findMax(LinkedList<? extends Number> list){
    findMaxPrivate(list);
}
static static <T extends Number> void findMaxPrivate(LinkedList<T> list){
    list.add(list.get(0));
}


A: The main difference is that in the second version you can access the type T whereas in the first one you can't.
For example, you might want to return something linked to T (e.g. returning T instead of void):
static <T extends Number> T findMax(LinkedList<T> list){...}

Or you might need to create a new list of Ts:
static <T extends Number> void findMax(LinkedList<T> list){
    List<T> copyAsArrayList = new ArrayList<> (list);
    //do something with the copy
}

If you don't need access to T, both versions are functionally equivalent.

A: The first one should be used if you just care that findMax accepts a list that meets certain criteria (in your case a List of type that extends Number).
static Number findMax(LinkedList<? extends Number> list) {
    Number max = list.get(0);
    for (Number number : list) {
        if (number > max) {
            max = number;
        }
    }
    return max;
}

This method returns Number. For example, this might be a problem if you have a class of your own that extends Number and has some special methods that you would like to use later on the result of this method.

The second one should be used when you plan to use exact type T in the method body, as a method parameter or as a return type of the method.
static <T extends Number> T findMax(LinkedList<T> list, T currentMax) {
    T max = currentMax;
    for (T number : list) {
        if (number > max) {
            max = number;
        }
    }
    return max;
}


Conclusion:
Functionally, they are pretty much equivalent except that list with an unknown type (?) cannot be modified.

A: I think there is already good answers about the access of parameter T in the body of second method. 
I would like to add that the second notation would be needed if you have many parameters which need to be linked by type. Example:
static <T extends Number> int getPosition(LinkedList<T> list, T element){...}

You would not be able to force the above constraint without using a generic type parameter <T>.
