Java generic parametrized parameter constrained by other parameters

Question

I have a generic class, which has a function that returns an instance of a functional interface:

/**
 * @param <FF> - FF is a functional interface
 */
public abstract class MyFunctionalInterfaceGetter<FF> {
    public abstract <PC, AC> FF getMyFunction(Class<PC> pojoClass, Class<AC> attributeClass);
}

And I have a couple of derived classes:

public class MyGetterGetter extends MyFunctionalInterfaceGetter<java.util.function.Function> {
    public <PC, AC> Function<PC, AC> getMyFunction(Class<PC> pojoClass, Class<AC> attributeClass) {
         ...
    }
}

public class MySetterGetter extends MyFunctionalInterfaceGetter<java.util.function.BiConsumer> {
    public <PC, AC> BiConsumer<PC, AC> getMyFunction(Class<PC> pojoClass, Class<AC> attributeClass) {
         ...
    }
}

And the question:
I do not thing so, but I wanted to know if there is any way to constrain the returning parametrized type from the function parameters at the parent class.
Something like this:

public abstract class MyFunctionalInterfaceGetter<FF> {
    public abstract <PC, AC> FF<PC, AC> getMyFunction(Class<PC> pojoClass, Class<AC> attributeClass);
}

I am using Java-8

`` has no bounds at all, so there could be subclasses like `class X extends MyFunctionalInterfaceGetter { … }` or `class Y extends MyFunctionalInterfaceGetter> { … }` You can not enforce specific type parameters when you didn’t even enforce a parameterized type (with exactly two type parameters) in the first place. — Holger, Oct 21 '22 at 06:51
Thank you, Holger, for replying. The thing is that the parameters of FF are dynamic, and depend on the invocation to getMyFunction (the parameters are decided at every getMyFunction invocation) As the derived classes can enforce those bounds, I can work with the derived types. But this makes that you cannot work with objects of the base type if you want FF to be bounded — Francisco Javier Rojas, Oct 22 '22 at 09:53
You can not work with the base type anyway. As said, `FF` can be anything, including just `java.lang.Object`. There’s no point in being able to say “*I don’t know (not even remotely) what it is, but whatever it is, it’s parameterized with X and Y*”. A type `X` can be subtype of `Y` or even `Z` with no relationship between `Q`, `W`, `A`, and `B`. Type arguments are only useful if you have an actual parameterized type giving them a meaning. — Holger, Oct 24 '22 at 12:18
@FranciscoJavierRojas Are you looking for higher-kinded generics? https://stackoverflow.com/questions/876948/higher-kinded-generics-in-java https://medium.com/@johnmcclean/simulating-higher-kinded-types-in-java-b52a18b72c74 — Dmytro Mitin, Oct 25 '22 at 09:12
Thank you Dmytro, for your answer, yes, it looks very similar to what I am looking for. It seems that it is not supported by Java Generics. — Francisco Javier Rojas, Oct 25 '22 at 17:51

score 0 · Answer 1 · answered Oct 21 '22 at 04:36

Move the generics to the class level and apply if to its subtypes:

public abstract static class MyFunctionalInterfaceGetter<FF, PC, AC> {
    public abstract FF getMyFunction(Class<PC> pojoClass, Class<AC> attributeClass);
}

public static class MyGetterGetter<PC, AC> extends MyFunctionalInterfaceGetter<Function<PC, AC>, PC, AC> {

    @Override
    public Function<PC, AC> getMyFunction(Class<PC> pojoClass, Class<AC> attributeClass) {
        ...
    }
}

public static class MySetterGetter<PC, AC> extends MyFunctionalInterfaceGetter<BiConsumer<PC, AC>, PC, AC> {

    @Override
    public BiConsumer<PC, AC> getMyFunction(Class<PC> pojoClass, Class<AC> attributeClass) {
        ...
    }
}

Thank you, Nikolas, for your answer. The thing is that I want the parameters of FF are dynamic, and to depend on every invocation to "getMyFunction". This approach makes that you can work with only one object of "MyFunctionalInterfaceGetter" — Francisco Javier Rojas, Oct 22 '22 at 09:59

Java generic parametrized parameter constrained by other parameters

1 Answers1

Linked