Java method can't be applied with Lambda expression

I've watched and read https://caveofprogramming.com/java/whats-new-in-java-8-lambda-expressions.html and I follow the same pattern I did for runner object which works fine.

Runner runner = new Runner();
runner.run(() -> System.out.println("Print from Lambda expression"));


Then, I try to create a simple interface and class to apply what I learned. I just want to replace the anonymous class with a lambda expression. My understanding is a lambda expression is a shorter code for the anonymous class and improve readability.

So, I tried to initiate another instance called eucalyptus1 and try to @Override the grow() method, but my IDE error message said:

eucalyptus1

@Override

grow()

grow() in com.smith.Eucalyptus cannot be applied to (lambda expression)

grow()

com.smith.Eucalyptus

(lambda expression)

Could anyone point me out what I misunderstand here?

The code is below:

// a simple interface
interface Plant
public void grow();


// apply interface to class
class Eucalyptus implements Plant
@Override
public void grow()
System.out.println("This is from Eucalyptus");



public class Main
public static void main(String args)

// Create an instance of Eucalyptus
Eucalyptus eucalyptus = new Eucalyptus();
eucalyptus.grow();

// Anonymous class Myrtle from Plant interface
Plant myrtle = new Plant()
@Override
public void grow()
System.out.println("This was running from anonymous class from Plant Interface");

;

myrtle.grow();

// Try to create a lambda expression from Plant interface
// and override grow() method
// by print ("This was running from Lambda expression")

// this won't work. why?
Eucalyptus eucalyptus1 = new Eucalyptus();
eucalyptus1.grow(() -> System.out.println("This from Lambda expression"));




3 Answers
3

The difference there is that you're trying to override the implementation of Eucalyptus which is a class that implement the interface.

Eucalyptus

Eucalyptus eucalyptus1 = new Eucalyptus();
eucalyptus1.grow(() -> System.out.println("This from Lambda expression"));
^__ // you cannot override a method using an instance of a class which is just an implementation of the interface


All you end up doing there is pass a lambda parameter and of course, a method without arguments in its definition wouldn't compile if supplied with one at the time of method call.

Instead, you can compare the way of implementing the lambda as :

//Anonymous class Myrtle from Plant interface
Plant myrtle = new Plant()
@Override
public void grow()
System.out.println("This was running from anonymous class from Plant Interface");

;
myrtle.grow();


can be represented as a lambda representation:

Plant lambdaRep = () -> System.out.println("This is running via lambda from Plant Interface");
lambdaRep.grow();


Problem

The method grow doesn't take any parameters, so you got the compilation error.

grow

Explanation

The lambda () -> System.out.println("This from Lambda expression") itself can represent a Plant (not Eucalyptus*) instance:

() -> System.out.println("This from Lambda expression")

Plant

Eucalyptus

Plant plant = () -> System.out.println("This from Lambda expression");


Try to create a lambda expression from Plant interface and override grow() method by print "This was running from Lambda expression".

Plant

grow()

"This was running from Lambda expression"

There is a slight misunderstanding here. A lambda isn't supposed to override a method, it's up to provide a method based on a @FunctionalInterface type.

@FunctionalInterface

*If you were to define an Eucalyptus object by a lambda, it would be ambiguous and unclear what method the lambda would represent. Therefore, it's prohibited (even for abstract classes with a single abstract method.)

Eucalyptus

Your use of lambda expression is incorrect here.

You use lambda expressions to implement an interface. In this case, you would be providing an implementation of Plant using a lambda expression, rather than calling that interface's method with a lambda expression:

Plant

Here's a normal use:

Plant eucalyptus1 = () -> System.out.println("This from Lambda expression");
eucalyptus1.grow(); // Prints "This from Lambda expression"


In other words, because you're having a functional interface, you should be able to avoid creating classes implementing it (anonymous or not).

So you should not need to create the Eucalyptus class at all.

Eucalyptus

Thanks for contributing an answer to Stack Overflow!

But avoid …

To learn more, see our tips on writing great answers.

Required, but never shown

Required, but never shown

By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.