Guice Beginner - How to bind concrete classes?

I have this class:

public class House {
    private final Door door;
    private final Window window;
    private final Roof roof;

    @Inject
    public House(Door door, Window window, Roof roof) {
        this.door = door;
        this.window = window;
        this.roof = roof;
    }
}

Where Door, Window and Roof are concrete classes. Now if I want to implement a Module for this scenario, I would do it like this:

public class HouseModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(Door.class).to(Door.class);
        bind(Window.class).to(Window.class);
        bind(Roof.class).to(Roof.class);
    }
}

But I wonder if this is the right way to bind concrete classes, or if there are easier ways. I feel there is an easier way to this.

EDIT

Just tried this out, and it doesn't seem to work:

1) Binding points to itself.
  at de.tarent.guice.ex._1.HouseModule.configure(HouseModule.java:10)

EDIT 2

It seems like no binding is needed at all:

Injector injector = Guice.createInjector();
House house = injector.getInstance(House.class);

Also seems to work.

This is the way to go:

protected void configure() {
    bind(Door.class);
    bind(Window.class);
    bind(Roof.class);
}

Since they are concrete classes, as Guice says, you can't bind them to themselves :-)

Check out the Binder docs, it notes:

bind(ServiceImpl.class);

This statement does essentially nothing; it "binds the ServiceImpl class to itself" and does not change Guice's default behavior. You may still want to use this if you prefer your Module class to serve as an explicit manifest for the services it provides. Also, in rare cases, Guice may be unable to validate a binding at injector creation time unless it is given explicitly.

Concrete classes with constructor marked as @Inject are automatically available for injection. But it helps the developer (you) know what is configured in the module.

Guice's Just-In-Time binding does exactly what you want. Given your Door, Window and Roof meet following requirements (quoted from the Guice documentation):

either a public, no-arguments constructor, or a constructor with the @Inject annotation

an empty Module implementation will be sufficient:

public class HouseModule extends AbstractModule {
    @Override
    protected void configure() {
    }
}