在Java8中将泛型类型参数标记为函数接口

我想将函数的类型参数限制为函数接口

大概是这样的：

public static <@FunctionalInterface T extends Function<A, B>> T foo () {
    return a -> bar;
}

publicstatictfoo（）{
返回一个->条；
}

此处不允许使用

@functionInterface

其目的是使返回具有类型参数类型的lambda成为可能。由于

T

可以是普通类，因此不允许返回lambda

---

是否有可能将类型参数限制为函数接口？

我的泛型fu很弱，但我认为这可能是：

public static <T, R> Function<T, R> foo() {
    // ...
}

返回一个getter，当使用给定的映射调用该getter时，将返回带有用于创建getter的键的条目：

import java.util.function.Function;
import java.util.*;
public class Example {

    public static final void main(String[] args) {
        Map<String,Character> mapLower = new HashMap<String,Character>();
        mapLower.put("alpha", 'a');
        mapLower.put("beta",  'b');

        Map<String,Character> mapUpper = new HashMap<String,Character>();
        mapUpper.put("alpha", 'A');
        mapUpper.put("beta",  'B');

        Function<Map<String, Character>, Character> getAlpha = makeGetter("alpha");

        System.out.println("Lower: " + getAlpha.apply(mapLower));
        System.out.println("Upper: " + getAlpha.apply(mapUpper));
    }

    public static <K, R, T extends Map<K,R>> Function<T, R> makeGetter(K key) {
        return a -> a.get(key);
    }
}

import java.util.function.function；
导入java.util.*；
公开课范例{
公共静态最终void main（字符串[]args）{
Map mapLower=新的HashMap（）；
mapLower.put（“alpha”，“a”）；
mapLower.put（“beta”，“b”）；
Map mapUpper=新的HashMap（）；
mappupper.put（“alpha”，“A”）；
mappupper.put（“beta”，“B”）；
函数getAlpha=makeGetter（“alpha”）；
System.out.println（“Lower:+getAlpha.apply（mapLower））；
System.out.println（“上限：+getAlpha.apply（mapUpper））；
}
公共静态函数makeGetter（K键）{
返回a->a.get（键）；
}
}

输出：

Lower: a Upper: A 下：a 上：A 我不认为类型擦除可以让您更接近于此，除非使用实例方法并参数化您的包含类。

正如前面讨论的那样，不可能做到这一点。不仅要注释类型参数，尤其要通过lambda表达式实现未知接口

在编译方法时

public static <@FunctionalInterface T extends Function<A, B>> T foo() {
    return a -> bar;
}

此代码适用于未知类型

A

和

B

以及

Map

的未知参数化，因为唯一的约束是方法

Map。get

接受

A

的实例，它接受任何内容，并返回

B

的实例，它与任何类型

一样？扩展B

将可分配给

B

现在，如果调用者具有任意子类型的

函数

，

X

，例如

interface X extends Function<String, Integer> {}

---

在这里，

X

作为函数接口的约束在调用方站点上被检查。

我希望返回类型是

函数的子类型。一些自己的类型，比如
A扩展函数
，而我希望能够在方法
Foo
@T.J.Crowder中放入
函数
的每一个可能的子类型。克劳德：你是对的，如果你不构造它，它就会工作。在您的回答中，它不起作用，因为
映射
类型与
函数
的返回类型不匹配，也就是说，
Map
映射到
Integer
，而您的
函数
将返回
R extends Integer
，这没有多大意义，因为
Integer
是
最终的
，但编译器对此仍然很挑剔，并坚持认为
Integer
不能转换为
R extensed Integer
@T.J.Crowder：这就是问题所在：“匹配Foo和Foo的任何子类型”意味着，如果调用方愿意，可以用Foo的子类型替换该类型。在这种情况下，返回的
函数必须返回Foo的子类型，但您无法实现，因为
映射的保证是返回Foo.LOL，我们采用了不同的方法。你做了一个绑定到你在地图上传递密钥的getter，我做了一个绑定到你在地图上传递密钥的getter.：-）
public static <A,B> Function<A,B> getter(Map<?, ? extends B> map) {
    return a->map.get(a);
}

interface X extends Function<String, Integer> {}

Map<String, Integer> map=new HashMap<>();
X x=getter(map)::apply;
x.apply("foo");