Lambdas passed in to a method

[Tim Bant]

Hi all,
Doing some studying for the Java SE17 cert, and noticed this snippet of code:

 interface Climb {
     boolean isTooHigh(int height, int limit);
  }
 
  public class Climber {
     public static void main(String[] args) {
        check((var x, var y) -˃ x ˃ y, 5); //HERE
     }
     private static void check(Climb climb, int height) {
       if (climb.isTooHigh(height, 10)) 
          System.out.println("too high");
       else 
          System.out.println("ok");
    }
 }

Where I have put //HERE, I haven't seen a method being called with a lambda like this before...how is this compatible with Check(Climb climb, int height)? Normally I would expect to see an Object (typically a Climb one)..


Can someone explain how?

[Tim Bant]

I have just spotted this : https://coderanch.com/t/668480/certification/lambda-Chapter-pg-Java-OCA#3119904
which I will take a look, but any help here would be welcomed too. Thanks

[Tim Bant]

I think I get it now, so my question is...

Is this first parameter just returning null so the if statement sees its as false?

public static void main(String[] args) {
        check((var x, var y) -> x > y , 5);
     }

[Tim Holloway]

Tim Bant wrote:I think I get it now, so my question is...

Is this first parameter just returning null so the if statement sees its as false?

public static void main(String[] args) {
        check((var x, var y) -> x > y , 5);
     }

When in doubt, extract it. A lambda is just a function/method with no name:

/**
 * Compare two values and return true if the first is grater than the second.
 * @param x first value 
 * @param y second value
 * @return true if x > y, otherwise false.
*/
private boolean relativeCompare(x, y) {
  return x > y;
}

... check(relativeCompare(x, y), 5);

Your example shouldn't be able to compile unless I missed something, since values were never defined for x or y. If it does, it would probably be defaulting, so it would be the results of relativeCompare(0, 0);

[Tim Bant]

Thanks - it compiles, and I think you are right, it must be defaulting to 0 which is odd since its a var/local param...odd

[Piet Souris]

There is nothing wrong with your check invoking. Check requires two arguments, a Climb and an int, and you supply these. Of course it compiles. But maybe I misundersttood something?

[Tim Bant]

I think Tim was referring to the values var x and var y, what values are they

[Tim Holloway]

Tim Bant wrote:I think Tim was referring to the values var x and var y, what values are they

If you don't assign a value to a numeric variable in Java, it will assume the default value of zero. That's a fundamental part of the language and was considered a vast improvement over older languages, which might simply leave whatever trash had been at that memory location previously. Zero might not be what you really wanted, but at least it was consistent and predictable, which greatly cuts down on random non-repeatable errors.

[Tim Bant]

I see - isn't var deemed local though, so technically doesn't have a default value as local variables don't have a default value? I wonder if an exception was made here

[Mike Simmons]

Hmmm, I think Tim is sending you on a path to more confusion.  The original code does, indeed compile (well, once you replace '˃' with '>' - those are not the same character).  And the advice about "extracting" the lambda doesn't help unless you understand it well enough to know what the lambda means.  The confusion comes because the compiler is filling in the gaps for several things that are not explicitly specified here.

Note that when "(var x, var y)" is used, it's used inside the check() method:

        check((var x, var y) -> x > y, 5);

So the compiler, to interpret the lambda, will use what it knows about the declared types of the check() method:

     private static void check(Climb climb, int height) {

The only way the compiler can interpret the check() call is if the first argument is a Climb instance.  So the question is, can the compiler do that?  This involves a lot of behind the scenes "magic" to make that work, in ways that are very carefully spelled out in the JLS, but a real pain to understand all the details.  But basically, when the compiler sees a lambda, and it's in a place where the type is a functional interface, that is, an interface with just one abstract method, then the compiler will do whatever it can to interpret the lambda as an instance of that interface.  In this case, the interface is Climb:

interface Climb {
    boolean isTooHigh(int height, int limit);
}

Well, that's a functional interface, with just one (non-static, non-default) method.  So the compiler will do its best to interpret the lambda

(var x, var y) -> x > y

as if it represents the missing method

    boolean isTooHigh(int height, int limit)

That means that the two vars are interpreted as ints.  

(int x, int y) -> x > y

It also needs to return a boolean - which we don't see happening, explicitly.  But here we can use another "magic" property of lambdas, that if they need to return something, and they end in a simple expression, they actually return that expression, without saying so.  So

(var x, var y) -> x > y

is equivalent here to

(int x, int y) -> { return x > y; }

and now it's considered as an implementation of the isTooHigh() method:

public boolean isTooHigh(int x, int y) -> { return x > y; }

In the elder days of Java (1.1), the closest equivalent of this would have been an anonymous class:

    public static void main(String[] args) {
      check(
          new Climb() {
            public boolean isTooHigh(int x, int y) {
              return x > y;
            }
          },
          5);
    }

(If you haven't learned about anonymous classes yet, just ignore for now.  They're much less important now than they used to be, though they're still legal and you do see them occasionally.)

But since Java 1.8, you can implement essentially the same thing much more concisely as

    public static void main(String[] args) {
      check((var x, var y) -> x > y, 5);
    }

or even

    public static void main(String[] args) {
      check((x, y) -> x > y, 5);
    }

(The var keyword wasn't adding anything useful there, anyway.)

As for this discussion of default values, I don't really know where that's coming from - I haven't tried to decode that branch of the conversation.  There are no default values for local variables or method parameters, only for member fields (static or non-static).  The only values that x and y ever have are the ones passed into it.  In the code shown, that's a height of 5 for x, and a constant 10 for y.  Defaults are not needed, which is good since they don't exist.

[Mike Simmons]

Sigh.  I keep finding things to fix in my post.  If you're replying, please re-read; I had some errors along the way...

[Mike Simmons]

There are a number of additional rules for how lambda conversion works; I wasn't trying to get them all, but to give enough to understand how that lambda is interpreted as a Click, which is what the original question seemed to be.