Why doesn't it output 'dog eat'

Question

code like this

public class LambdaTest {
    public static void main(String[] args) {
        final Animal animal = Dog::new;
        animal.eat();
    }
}

@FunctionalInterface
interface Animal {
    void eat();
}

class Dog implements Animal {

    public Dog() {
        System.out.println("dog init.");
    }

    @Override
    public void eat() {
        System.out.println("dog eat");
    }

When I ran this code, "dog init." was printed to the console, but "dog eat" was not. Why is that? Can someone tell me the reason?

I expected "dog init" and "dog eat" to be printed, but only "dog init" was printed. Additionally, I'm puzzled as to why there was no error when Animal animal = Dog::new;.

I'm surprised it outputs anything since it doesn't compile. `Dog::new` is a reference to the `Dog` constructor, not a `Dog`, so you can't assign it to a `Dog` variable. Do you maybe still have an older version that you compiled before and still run? — daniu, Feb 16 '23 at 09:35
@daniu OP is not assigning `Dog::new` to a `Dog` variable though, but an `Animal`, which does compile. — Sweeper, Feb 16 '23 at 09:38
`Dog::new` is a method reference. It does not call the constructor. `new Dog()` calls the constructor. The line is equivalent to `Animal animal = () -> new Dog();` — knittl, Feb 16 '23 at 09:40
@Sweeper you're right, it does compile and run, but I'm somewhat surprised even though I do understand why. I was going to write an answer but knittl ninja'd me. — daniu, Feb 16 '23 at 09:45
You basically created a new anonymous class instance of `Animal` and implemented `eat()` to call `new Dog()`. That's what the method reference is doing. Add another method to `Animal` and you'll see the compiler complaining about functional interfaces not allowed to have more than one method. Replace `Dog::new` with `new Dog()` to fix your issue. — Thomas, Feb 16 '23 at 09:47

knittl · Accepted Answer · 2023-02-20T10:29:18.007

Animal is a functional interface with a single method void eat() (void return, no parameters) – also known as SAM type (single abstract method).

It is structurally identical to the java.util.Runnable interface (interface Runnable { void run(); }). Your code could as well be written as:

final Runnable runnable = Dog::new;
runnable.run(); // calls the constructor

You can assign it any lambda or method reference with zero arguments and no return value, e.g. () -> {}.

Dog::new is a method reference and equivalent to the lambda () -> { new Dog(); }. If you look closely, you will notice that this lambda does not return anything. It constructs a new Dog instance and then forgets about it again.

Assigning a method reference or a lambda to a variable does not execute it (yet). You have to explicitly invoke the lambda by calling the named method from your interface.

Now, your animal is an instance of your Animal interface and got assigned a method reference which can then be invoked later. animal.eat() invokes the assigned method reference, calling the constructor.

If you want your variable animal to hold a Dog instance and then invoke the eat method on it, call the constructor directly: Animal animal = new Dog();

The "problem" is the signature of your eat method, because it is equivalent to Runnable#run and allows assigning any "empty" action.

Lambdas and method references were introduced with Java 8. In Java versions before, you had to create an anonymous class to achieve the same behavior:

final Animal animal = new Animal() {
  @Override public void eat() {
    new Dog();
  }
};
animal.eat(); // calls "eat" of the anonymous instance, which in turn calls the constructor; does NOT call `Dog#eat`

I am a bit surprised that `Dog::new` matches `Runnable` since it really is a `Supplier`. I could have sworn this used to mismatch due to the different return type of the method - did that change in recent Java versions perhaps? — daniu, Feb 16 '23 at 09:48
@daniu I would have expected that too, but `Dog::new` could either be `() -> new Dog()` or `() -> { new Dog(); }`. I tested with Java 11, perhaps Java 8/9 behaved differently? — knittl, Feb 16 '23 at 09:51
@daniu It *could* be, but the value resulting from an expression *may* be discarded. I think this is called *void-compatibility*, but I'm not sure. — MC Emperor, Feb 16 '23 at 09:53
@daniu That behaviour has been there since the introduction of lambdas in Java 8. — Mark Rotteveel, Feb 16 '23 at 09:58
@daniu Interestingly, if you create two methods `void doSomething(Runnable r) { }` and ` void doSomething(Supplier s) { }`, then calling `doSomething(Dog::new)` will execute the latter, but using a *type witness* or a cast to `Runnable` runs the former. See [example code](https://ideone.com/e0Ep1m). — MC Emperor, Feb 16 '23 at 11:29

score 2 · Answer 2 · answered Feb 16 '23 at 09:52

Animal is an interface with a single abstract method, eat. This method does not take any parameters and does not return anything. Because of this, it can represent any function that takes no parameters. For example:

Animal foo = () -> System.out.println("foo");

Now if I call foo.eat(), it will run the code in the lambda, which prints "foo".

I can also use a method reference instead of a lambda:

Animal foo = SomeClass::someStaticMethod;

Now foo.eat() will run the parameterless method called someStaticMethod located in SomeClass.

Notice that this works in exactly the same way as using the built-in Runnable interface and called its run method. Yours is just called Animal and eat, rather than Runnable and run.

So by the same logic, using a constructor reference of Dog will invoke the constructor of Dog.

Animal foo = Dog::new;
Runnable bar = Dog::new;

// these two lines do the same thing:
foo.eat();
bar.run();

Would you still have the confusion if you have written the code with Runnable instead?

Note that the fact that Dog implements Animal does not matter here. Dog implements Animal just means that you can do:

Animal animal = new Dog();

which has a completely different meaning. If at this point I do animal.eat(), then it will output what you expect - "dog eat".

Alternatively, you could also make a method reference to a newly-created Dog's eat method for it to output "dog eat":

Animal animal = new Dog()::eat;

Why doesn't it output 'dog eat'

2 Answers2