8

What is the difference between the following two method declarations:

 1. <R> Stream<R> myFunc(Function<? super T, ? extends R> mapper);    
 2. Stream<R> myFunc(Function<? super T, ? extends R> mapper);

For the 2nd declaration to compile, I need to add type parameter to class like this.

public class MyGenericsTest<T, R>

In this case compiler is ensuring that the return type of myFunc is determined at the compile time. The compiler could have known that from the method signature as well. I am confused on why these 2 declarations are treated differently by compiler.

Improve this question
1
  • In one of these cases, R is a generic type argument for the class, not just the one method. Commented Sep 29, 2016 at 3:47

2 Answers 2

Reset to default
11

By writing <R> Stream<R> myFunc(Function<? super T, ? extends R> mapper) you are telling the compiler that:

  • R is any class and is local to the method (by starting with<R> at the beginning)
  • The return type is a Stream of R
  • T is a class specified in the type parameter of MyGenericsTest<T> (if you dont specify it, it wont work as the compiler will not know T)

If you change to Stream<R> myFunc(Function<? super T, ? extends R> mapper), R and T are not local (no <R, T> at the beginning of the method) and the compiler expects them to be defined at a class level as MyGenericsTest<T, R>

Improve this answer
Sign up to request clarification or add additional context in comments.

4 Comments

:The compiler an infer that R is local to the method by looking at the class and method signature. Why does <R> has to be explicitly provided at the beginning of method declaration.
What would happen if you have a file R.java in your project ? How the compiler would know if the R in your method is mean to be a generic or a concrete class ? By explicitly declaring <R> you are telling the compiler that everything in the method or in the class file which is labeled R is a generic.
"The compiler expects them to be defined at a class level"... strictly speaking, this is not true. It has to be defined somewhere in an enclosing scope, but by using an inner class you can make it so that R is defined on a generic method instead of a generic class. It's legal, but not commonly used.
@ajb You're right of course, but my answer is targeted to OP who use class level declaration. Thought it would be confusing to go through all possible case when OP seem to be new to generics.
1

The second form:

Stream<R> myFunc(Function<? super T, ? extends R> mapper);

really isn't any different from this:

Stream<String> myFunc(Function<? super T, ? extends String> mapper);

to the compiler, except that it uses a different type. The second one returns a stream of String. The first one returns a stream of R, whatever R is. The compiler already knows what String is. For the first one, the compiler has to know what R is, which means it has to be defined somewhere. It can be a generic parameter on an outer class, but it could also be a non-generic class that you import from somewhere else (written by someone who is very bad at coming up with meaningful names).

Keep in mind that although we often use single upper-case letters as generic parameters, that's just a human convention. The compiler just treats it like any other identifier.

But that's why your two examples are so different. The first one is a syntax that defines the method as a generic method with a type parameter that you're calling R. The second one is the exact same syntax as a method that returns Stream<String> or List<Integer> or something.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.