Java unchecked warning issues with understanding how to fix

I am having hard time to understand the difference between two declarations on java generics.

lets say I have the following two interfaces

@FunctionalInterface
public interface CheckedFunction<T, R, E extends Throwable> {
   R apply(T t) throws E;
}

public interface SomeInterface<DTO, E2 extends Throwable> {

    <E extends Throwable> CheckedFunction<Object, String, E> firstFunction();

    CheckedFunction<String, DTO, E2> secondFunction();
}

So now I created an implementation of those and an "unchecked" warning popped which is what I am trying to understand.

The implementation is the following

public class TmpImpl implements SomeInterface<TmpObj, IOException> {

    final ObjectMapper objectMapper = new ObjectMapper();

    @Override
    public CheckedFunction<Object, String, JsonProcessingException> firstFunction() {
        return objectMapper::writeValueAsString;
    }

    @Override
    public CheckedFunction<String, TmpObj, IOException> secondFunction() {
        return json -> objectMapper.readValue(json, TmpObj.class);
    }

    public static class TmpObj {
        String s;
    }
}

for this example I am using com.fasterxml.jackson.databind.ObjectMapper as it does exactly what I want and generates the warning.

So the firstFunction now has a warning

Unchecked overriding: return type requires unchecked conversion. Found 'CheckedFunction<java.lang.Object,java.lang.String,com.fasterxml.jackson.core.JsonProcessingException>', required 'CheckedFunction<java.lang.Object,java.lang.String,E>

while the second is just fine.

Why is this happening ? I am clearly missing something which I haven't noticed in order to fix it!

note JsonProcessingException extends IOException (declaration: public class JsonProcessingException extends IOException )

The short answer is that your implementation is dictating JsonProcessingException whereas the interface allows for E to be inferred.

In other words, according to the interface, this should be possible:

SomeInterface<String, RuntimeException> runtimeExceptionSomeInterface = null;
CheckedFunction<Object, String, RuntimeException> function = 
                     runtimeExceptionSomeInterface.firstFunction();

This declaration:

<E extends Throwable> CheckedFunction<Object, String, E> firstFunction();

allows the caller to specify the concrete argument for E, which is exactly what I did in the above example (using RuntimeException).

However, your implementation is statically forcing JsonProcessingException:

public CheckedFunction<Object, String, JsonProcessingException> firstFunction() {
	return objectMapper::writeValueAsString;
}

That is to say you've disregarded the incoming E type argument and forcefully substituting it with JsonProcessingException.

In short, if you want the firstFunction() to be generic, then implement it accordingly:

@Override
public <E extends Throwable> CheckedFunction<Object, String, E> firstFunction() {
	return objectMapper::writeValueAsString;
}

However, the above fails return objectMapper::writeValueAsString; with an unhandled JsonProcessingException, which I suspect led to your implementation.

That simply means that your use of a generic Throwable parameter is wrong.

A first attempt at solving it would be to use SomeInterface's E2 variable:

interface SomeInterface<DTO, E2 extends Throwable> {
	CheckedFunction<Object, String, E2> firstFunction();
	CheckedFunction<String, DTO, E2> secondFunction();
}

which will solve the problem if implemented with:

class TmpImpl implements SomeInterface<TmpObj, IOException> {
    //...
	@Override
	public CheckedFunction<Object, String, IOException> firstFunction() {
		return objectMapper::writeValueAsString;
	}

However, you would still have a problem because it's not the user of SomeInterface that knows what exception will be thrown, but the implementation. This means that you should declare the exception type on the API, rather than making it a generic argument:

interface SomeInterface<DTO> {
	CheckedFunction<Object, String, IOException> firstFunction();
    //...
}

class TmpImpl implements SomeInterface<TmpObj> {

	//...

	@Override
	public CheckedFunction<Object, String, IOException> firstFunction() {
		return objectMapper::writeValueAsString;
	}
}

Which is to say that SomeInterface and its implementations know the range of exceptions to be dealt with, therefore the functions they return know of, in this case, IOException (which is selected because you know it includes JsonProcessingException, among other types)