Question

我正在学习Lambda，但我遇到了一些我无法解决的问题。

最初我的代码是：

package Lambdas;

@FunctionalInterface
interface NumericFunc2 {
    <T extends Number> T func(T n);
}

class Lbd_488_NumericFunc_SelfTest {
    public static void main(String args[]) {
        // This block lambda returns the smallest positive factor of a value.
        NumericFunc2 smallestF = (n) -> {
            double result = 1;
            // Get absolute value of n.
            n = n < 0 ? -n : n;
            for (int i = 2; i <= n / i; i++)
                if ((n % i) == 0) {
                    result = i;
                    break;
                }
            return result;
        };
        System.out.println("Smallest factor of 12 is " + smallestF.func(12));
        System.out.println("Smallest factor of 11 is " + smallestF.func(11));
    }
}

然而，我的操作员（<，-，/）旁边一直出现错误。 PS：即使我将其更改为<T extends Double>，我也会遇到相同的错误。

现在，如果我通过添加参数类型来更改代码，我会得到错误，说“目标方法是通用的”：

即使我将其更改为<T extends Double>，我也会遇到相同的错误。

package Lambdas;

@FunctionalInterface
interface NumericFunc2 {
    <T extends Number> T func(T n);
}

class Lbd_488_NumericFunc_SelfTest {
    public static void main(String args[]) {
        // This block lambda returns the smallest positive factor of a value.
        NumericFunc2 smallestF = (Double n) -> {
            double result = 1;
            // Get absolute value of n.
            n = n < 0 ? -n : n;
            for (int i = 2; i <= n / i; i++)
                if ((n % i) == 0) {
                    result = i;
                    break;
                }
            return result;
        };
        System.out.println("Smallest factor of 12 is " + smallestF.func(12));
        System.out.println("Smallest factor of 11 is " + smallestF.func(11));
    }
}

但是，如果我将类从非泛型更改为泛型，一切正常，就像这段代码一样：

package Lambdas;

@FunctionalInterface
interface NumericFunc2<T extends Number>  {
    T func(T n);
}

class Lbd_488_NumericFunc_SelfTest {
    public static void main(String args[]) {
        // This block lambda returns the smallest positive factor of a value.
        NumericFunc2<Double> smallestF = (n) -> {
            double result = 1;
            // Get absolute value of n.
            n = n < 0 ? -n : n;
            for (int i = 2; i <= n / i; i++)
                if ((n % i) == 0) {
                    result = i;
                    break;
                }
            return result;
        };
        System.out.println("Smallest factor of 12 is " + smallestF.func(12));
        System.out.println("Smallest factor of 11 is " + smallestF.func(11));
    }
}

所以，我的问题是。我正在做什么工作我的第一部分代码？如何在非泛型类中正确使用lambdas和泛型方法？

Answer 1

答案是无法对Number对象执行此类数字操作。没有办法; 这与lambdas无关，与Number抽象类无关，只是没有提供这些功能。

在不知道Number是什么类型的情况下，甚至没有办法获得Number的绝对值。你无法看到它是正面还是负面，你不能否定它，你不能添加，减去或乘以它。您可以使用Number执行唯一的操作将其转换为另一种基本类型，但您无法将其转换回来，也无法使用它进行数学运算。

Answer 2

根据JLS，泛型和lambda不会一起工作。 This eclipse bug report使用一些代码示例对其进行了讨论。

为了使其有效，你必须回到anonymous inner classes。即你必须在你的功能周围写下完整的new NumberFunc() {...} mambo-jambo。

我必须在方法体中进行一些其他更改才能使其编译：

result是装箱Double，因此我可以将其投放到T
方法内部我正在使用n的doubleValue（）因为原始运算符不能用于T extends Number。

把它放在一起：

class Lbd_488_NumericFunc_SelfTest {
    public static void main(String args[]) {
        // This block lambda returns the smallest positive factor of a value.
        NumericFunc2 smallestF = new NumericFunc2() {
            public <T extends Number> T func(T n) {
                Double result = 1d;
                // Get absolute value of n.
                double nAbs = n.doubleValue() < 0 ? -n.doubleValue() : n.doubleValue();
                for (int i = 2; i <= nAbs / i; i++)
                    if ((nAbs % i) == 0) {
                        result = (double) i;
                        break;
                    }
                return (T) result;
            }
        };
        System.out.println("Smallest factor of 12 is " + smallestF.func(12));
        System.out.println("Smallest factor of 11 is " + smallestF.func(11));
    }
}

Lambda和通用方法

2 个答案: