Java Lambda表达式参数[重复]

Question

我正在尝试在Java中使用Lambda表达式来理解以下方法参考代码：

interface MyFunc<T> {

    boolean func(T v1, T v2);
}

class HighTemp {

    private int hTemp;

    HighTemp(int ht) {
        hTemp = ht;
    }

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

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

class InstanceMethWithObjectRefDemo {

    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;

        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::sameTemp,
                new HighTemp(89));
        System.out.println(count + " days had a high of 89");

        HighTemp[] weekDayHighs2 = {new HighTemp(32), new HighTemp(12),
            new HighTemp(24), new HighTemp(19),
            new HighTemp(18), new HighTemp(12),
            new HighTemp(-1), new HighTemp(13)};

        count = counter(weekDayHighs2, HighTemp::sameTemp,
                new HighTemp(12));
        System.out.println(count + " days had a high of 12");

        count = counter(weekDayHighs, HighTemp::lessThanTemp,
                new HighTemp(89));
        System.out.println(count + " days had a high less than 89");

        count = counter(weekDayHighs2, HighTemp::lessThanTemp,
                new HighTemp(19));
        System.out.println(count + " days had a high of less than 19");
    }
}

我的问题是，为什么函数sameTemp只有一个参数？接口声明它必须有2个参数，所以对我来说没有意义。也许hTemp实例变量对这两个都足够了？我从Java完整参考书中获得了这一点，作者在那里解释了这一点：

块引用

在程序中，请注意HighTemp有两个实例方法：sameTemp（

谢谢




Answer 1

很多人在进行OO编程时忽略的是。。。这是如何真正实现的。假设：

class C {
  public int foo(int parm) { return parm; }

关键是：在对象“上”调用方法的想法是一种抽象。您将如何在汇编程序中实现它；以便CPU可以实际执行该代码。您意识到：“调用”在那里是不可能的。在那个层面上，您只调用内存中的某个地方的函数。但是函数怎么会知道它拥有的对象呢？！

导致很少有人知道的事情-您可以将上述代码编写为：

class C {
  public int foo(C this, int i) {
        System.out.println("i: " + i);
        return i;
   }
}

为了安全起见，我还在eclipse中为此编写了一个小测试：

@Test
public void testIt() {
    assertThat(new C().foo(5), is(5));
}

在eclipse中运行良好，单元测试通过，并打印“i:5”。

所以，整个秘密是：当在对象上定义方法时，总是有一个（通常不可见的）第一个参数“this”给定给该方法！

因此：虽然您的方法看起来只接受一个参数，但“缺少”参数就是您调用该方法的对象！

从这个意义上说：boolean func（T v1， T v2）要求T类型的两个参数。这两个方法，如boolean sameTemp（HighTemp ht2）...可以写为boolean sameTemp（HighTemp this， HighTemp ht2）；等等：T类型的两个参数。