Java lambda method and new Object

Question

I have the following code:

public class RefDemo {

    static class Demo implements Runnable {

        public Demo() {
            System.out.println(this.toString() + "-----");
        }

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

    public static void main(String[] args) {
        Runnable runnable = Demo::new; // lambda ref constructor method
        runnable.run(); // does not do anything
        System.out.println(runnable);
        Runnable demo = new Demo(); // using new to create a Demo instance
        demo.run();
        System.out.println(demo);
    }
}

Which prints:

RefDemo$Demo@7291c18f----- // lambda run constructor method print
RefDemo$$Lambda$1/793589513@34a245ab // main method print
RefDemo$Demo@7cc355be-----
run
RefDemo$Demo@7cc355be

I don't know why the code does not print run when calling runnable.run();

Why does that happen?

runnable.run() calls the constructor, not the run method of Demo. — luk2302
– luk2302, Commented Apr 30, 2018 at 9:07

Eugene · Accepted Answer · 2018-04-30 11:59:02Z

42

This code

Runnable runnable = Demo::new;

Is equivalent to this code

Runnable runnable = new Runnable() {
    @Override 
    public void run() {
        new Demo();
    }
};

So you are not referring to the run method of Demo but to the constructor.

edited Apr 30, 2018 at 11:59

Eugene

122k17 gold badges219 silver badges335 bronze badges

answered Apr 30, 2018 at 9:26

TomVW

1,59014 silver badges29 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

luk2302 · Accepted Answer · 2018-04-30 09:10:36Z

20

You are simply using Runnable in too many places and confusing yourself. The following code makes it a bit clearer what is happening:

public class RefDemo {

    static class Demo {

        public Demo() {
            System.out.println(this.toString() + "-----");
        }

        public void something() {
            System.out.println("something");
        }
    }

    public static void main(String[] args) {
        Runnable runnable = Demo::new; 
        runnable.run();

        System.out.println(runnable);

        Demo demo = new Demo();
        demo.something();

        System.out.println(demo);
    }
}

Runnable runnable = Demo::new; means that you now have a reference to the constructor of Demo (which still works after dropping the conformance to the Runnable interface). And you store that reference in a variable of type Runnable which only works because their functional interfaces are compatible. Calling run on that reference then simply calls the constructor, not the run / something method of Demo.

answered Apr 30, 2018 at 9:10

luk2302

57.5k24 gold badges108 silver badges151 bronze badges

3 Comments

lonecloud Over a year ago

Runnable runnable = Demo::new; this mean only using lambda create a virtual anon instances which implements Runnable interface, but why it can print RefDemo$Demo@7291c18f----- //lambda run constructor methods print?

Eugene Over a year ago

@lonecloud what if for the purpose of the example you re-write it like this

Runnable x = new Runnable() {             @Override             public void run() {                 new Demo();             }         };

would that make more sense?

luk2302 Over a year ago

@lonecloud because you still end up calling the constructor, and inside the constructor this / toString still refers to a Demo instance. Printing the runnable itself however outputs the anonymous name of the lambda.

Oleksandr Pyrohov · Accepted Answer · 2018-04-30 14:56:03Z

The lines:

Runnable runnable = Demo::new;
runnable.run();

Are equivalent to:

Runnable runnable = new Runnable() {
    @Override
    public void run() {
        new Demo(); // Creates an instance of the Demo class, and nothing more
    }
};
runnable.run();

At the same time, your intention was to invoke the run method from the Demo class through a method reference. Therefore, I assume you meant the following:

Runnable runnable = new Demo()::run;
runnable.run();
// But, this is a little bit redundant...

The above code is equivalent to:

Demo demo = new Demo();
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        demo.run();
    }
};
runnable.run();

P.S. You don't really need a method reference here, so just write:

new Demo().run();

Or:

Runnable demo = new Demo();
demo.run();

Eran · Accepted Answer · 2018-04-30 09:09:17Z

6

Demo::new is the constructor of the Demo class. Since you assign it to a reference to the Runnable interface, calling runnable.run() invokes the constructor and creates a new Demo instance. The run() method is not executed.

If you want to define a Runnable instance that calls Demo's run() method using a method reference, you can write:

Runnable runnable = new Demo()::run;

Of course, since Demo already implements Runnable, it's much simpler to just write:

Runnable runnable = new Demo();

answered Apr 30, 2018 at 9:09

Eran

395k57 gold badges726 silver badges793 bronze badges

Collectives™ on Stack Overflow

Java lambda method and new Object

4 Answers 4

Comments

3 Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

3 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related