Understanding the syntax

Considering the important part:

<T> Optional<T> empty()

T it is a variable of Type. This works more or less like a variable in a template, where you can replace T with any type, remembering that type in Java is synonymous with class (not to be confused with *primitive types).

The first <T> says: this method will use a generic type T somewhere. It's like a tip to the compiler (and for the inattentive programmer).

The return type of the method Optional<T> then says that the generic type of Optional must be of the same generic type as the method.

Confused, right? When will Java know the type T? This occurs at the moment when you are going to use the method. As @Maniero has already said, when you call the method assigning the result to a certain type, Java manages to infer the type used in that call.

For example, if you are assigning the method return to a variable of type Optional<String>, then T = String and you can read the method as:

Optional<String> empty()

In fact, more advanced IDEs like Eclipse and IntelliJ will show the signature with proper substitution of T during autocomplete whenever it is possible to infer type by the current context.

It is good to remember that generic type inference is a compile-time guarantee that there will be no mismatch between types during assignments and accesses. So this nothing influences during program execution.

Another example

This is not the only way the compiler understands the generic type. A classic example is a method that returns the same type passed by parameter:

static <T> T instanciar(Class<T> classe) throws IllegalAccessException, InstantiationException {
    return classe.newInstance();
}

In the same way as in the first example, <T> says that the method is generic, the return will be of type T and the method receives a class of type Class<T>. Usage example:

Cliente c = instanciar(Cliente.class);
Produto p = instanciar(Produto.class);

How does Java infer the type T here? The compiler looks at the class type passed in the parameter and thus ensures that the returned value is of the same type.

Different from the case of the question, where the type is inferred by the variable that receives the return of the method, here the type is inferred by one of the given parameters.

For example, Cliente.class is an attribute that returns an object of type Class<Cliente>, so the return of the first call will be to Type Cliente, where T = Cliente.

Because <T> is required before the method

There are generic classes/interfaces and generic methods. If the class / interface is generic, its methods can use the generic type.

Example:

interface Generico<T> {
    T empty();
}

Or:

class Generico<T> {
    T empty() { ... }
}

However, if only the method is generic, the declaration needs to come before the method. This applies to static and Instance Methods.

Note that you can mix generic classes and methods and use different names for the variables of types:

class Generico<T> {
    T empty() { ... }
    static <X> Optional<X> empty() { ... }
    <Y> Optional<Y> of(Y instance) { ... }
}

However, consider that there is a convention for variable names of types .

I believe that the decision to require the declaration of the generic type was made for reasons of code readability, as well as avoiding obscure syntaxes so as not to confuse a generic type T with a class T {}.

Is the generic type strictly necessary?

No. Generics in Java are just a matter of security for the developer.

You may well do this:

public static Optional empty() {
    return Optional.empty();
}

And we went back to the era of Java 1.4, where there were no generics, but in compensation casts and errors of ClassCastException appeared everywhere.