10 
public interface MyFunc<T> {

    boolean func(T v1, T v2);

}

public class HighTemp {

    private int hTemp;

    HighTemp(){

    }
    public HighTemp(int ht) {
        this.hTemp = ht;
    }

    boolean sameTemp(HighTemp ht2){
         return hTemp == ht2.hTemp;
    }

     boolean lessThanTemp(HighTemp ht2){
        return hTemp < ht2.hTemp;
    }
}

class InstMethWithObjRef {

    static <T> int counter(T[] vals, MyFunc<T> f, T v){
        int count = 0;

        for (int i = 0; i < vals.length; i++) {
            if(f.func(vals[i], v)) count++;
        }
        return count;
    }
    public static void main(String[] args) {
        int count;
        //Create an array of HighTemp objects.
        HighTemp[] weekDayHighs = {new HighTemp(89), new HighTemp(82),
                                   new HighTemp(90), new HighTemp(89),
                                   new HighTemp(89), new HighTemp(91),
                                   new HighTemp(84), new HighTemp(83)};
        count = counter(weekDayHighs, HighTemp::lessThanTemp,new HighTemp(89));     
        System.out.println(count);          
    }
}

Please explain how

  1. boolean sameTemp() is compatible with func() in Functional interface.
  2. sameTemp() method got implemented on func() in Functional Interface.
  3. count = counter(weekDayHighs, HighTemp::sameTemp, new HighTemp(89)); is working

Please Explain All points separately.

4

4 回答 4

10

HighTemp::lessThanTempis的等价lambda 表达式

(highTemp1, highTemp2) -> {
     return highTemp1.lessThanTemp(highTemp2);
}

这是对特定类型的任意对象的实例方法的Java8命名引用的特性之一

考虑以下示例，

interface FIface<T> {
    int testMethod(T a, T b);
}

class Test2 {

    private String str;

    Test2(String str) {
        this.str = str;
    }

    int ok(Test2 test2) {
        System.out.println("Currnet String : "+ this.str);//Refer to t1
        System.out.println("Test String : "+test2.str);//Refer to t2
        return 0;
    }

}

public class Test {

    public static <T> int checkCall(T t1, T t2, FIface<T> fiFace) {
        //Here Test2 :: ok is equivalent to t1.ok(t2)
        return fiFace.testMethod(t1, t2);
    }

    public static void main(String[] args) {
        checkCall(new Test2("a"), new Test2("b"), Test2 :: ok);
    }

}

输出

Currnet String : a
Test String : b

注意这里Test2 :: ok对调用有效，甚至ok方法不是静态的。

当您调用checkCall函数式接口的方法时，您仍然有两个参数，t1并且t2对于该有效的 lambda 表达式可以具有参数，(Test t1, Test t2)因此您的方法Test2 :: ok在此处对调用有效。在内部它以这种方式工作t1.ok(t2)。

因此，fiFace.testMethod(t1, t2);将调用方法为t1.ok(t2)

于 2015-08-29T08:03:53.087 回答
3

首先，我不是专业的程序员。我也很难理解所谓的“对特定类型的任意对象的实例方法的引用”，我认为这可能对从谷歌搜索来到这里的人有所帮助。
在 lambda 表达式的帮助下，我稍微理解了一点。

在您的代码HighTemp::lessThanTemp中，作为 Lambda 表达式看起来像(x,y)->{x.lessThanTemp(y);}用这个 lambda 表达式替换方法引用会产生相同的结果。上面的 Lambda 表达式或方法引用都告诉接口方法要做什么。
当您使用方法引用时，它会告诉接口方法使用给定类中的引用方法，以执行其功能。因此，如果您转换HighTemp::lessThanTemp对英语单词来说，它听起来像“从类中实现方法作为接口函数的实现lessThanTempHighTemp”。您可能已经注意到，在这种情况下，返回类型和参数类型应该是兼容的。否则你不能实现一个接口。

我将为您提供另一个简单的示例代码。更多示例有助于理解这个概念。

interface myint{
    int returnit(Test t ,int y);
}
class Test{
    int x=0;
    public Test(int x){
        this.x=x;
    }

    public int addNumbers(int y){
        return x+y;
    }
    public int subtractNumbers(int y){
        return x-y;
    }

}

public class myclass{
    private static void myMethod(Test t,myint inf,int y){
        int x=inf.returnit(t, y);
        System.out.println(x+"");
    }
    public static void main(String[] args){
        myMethod(new Test(4),Test::addNumbers,7);
        myMethod(new Test(4),Test::subtractNumbers,7);
    }
}


输出将是：

11
-3


这是我能想象到的最简单的方法。查看如何使用上述句型匹配返回类型和参数类型。花一些时间在上面。

于 2016-01-21T10:08:39.027 回答
1

这是界面 

package learninglambdaexp;

@FunctionalInterface
public interface TempInterface {

    public boolean validTemp(Temperature temp);
}

这是课

package learninglambdaexp;

public class Temperature {

    private int temp;

    public Temperature(int temp) {
        this.temp = temp;
    }

    public boolean isEvenTemp() {
        return temp % 2 == 0;
    }

    public boolean isOddTemp(){
    return !isEvenTemp();
    }
}

这是具有主要方法的类

package learninglambdaexp;

import java.util.ArrayList;
import java.util.List;

public class AnotherMainClass {

    public static void main(String[] args) {

        List<Temperature> tempCollection = new ArrayList<>();
        tempCollection.add(new Temperature(100));
        tempCollection.add(new Temperature(20));
        tempCollection.add(new Temperature(30));
        tempCollection.add(new Temperature(40));
        tempCollection.add(new Temperature(50));
        tempCollection.add(new Temperature(60));
        tempCollection.add(new Temperature(70));
        int k1 = countVariation(tempCollection, Temperature::isEvenTemp);
        //int k2 = countVariation(Temperature::lowTemp);
        System.out.println(k1);
        // System.out.println(k2); 
    }

    private static int countVariation(List<Temperature> tempCollection, TempInterface ti) {
        int count = 0;
        for (Temperature eachTemp : tempCollection) {
            if (ti.validTemp(eachTemp)) { // (eachTemp) -> {return eachTemp.isEvenTemp();};
                count++;
            }
        }
        return count;
    }
}

有一个论点更容易理解

于 2017-03-13T16:28:25.873 回答
0

如果我错了，请纠正我，但我对这种类型的方法引用（对特定类型的任意对象的实例方法的引用）的看法是，当我们将方法引用传递给计数器时，在这种情况下方法，创建实现MyFunc接口的匿名类的实例。然后，在这个匿名类中，我们重写了传递两个参数的func方法。然后在func方法内部，lessThanTemp方法是这样调用的：

v1.lessThanTemp(v2);

所以对我来说，这个概念看起来像这样：

public class Demo {
    public static void main(String[] args) {
        AnonymousClass an = new AnonymousClass();
        System.out.println(an.apply(new SomeClass(3), 4));
    }
}
interface SomeInterface {
    int apply(SomeClass obj, int n);
}

class SomeClass {
    private int n;

    SomeClass(int n) {
        this.n = n;
    }

    int add(int n) {
        return this.n + n;
    }
}
class AnonymousClass implements SomeInterface {

    @Override
    public int apply(SomeClass o, int n) {
        return o.add(n);
    }
}
于 2019-11-26T19:58:39.347 回答