If we want to create only one instance of the class, then the @Singleton annotation can be used to mark the implementation class. As long as a the singleton object lives, the injector lives in context, but in the same application, it is possible to have multiple injectors, and in that case, each injector is associated with a different instance of a singleton-scoped object:

@Singleton
public class DatabaseConnection{

    public void connectDatabase(){
    }

    public void disconnectDatabase(){
    }
}

Another way to configure a scope is by using a bind statement in the module:

public class ApplicationModule extends AbstractModule{

  @Override
  protected void configure() {
    //bind service to implementation class
    bind(NotificationService.class).to(SMSService.class).in(Singleton.class);
  }

}

When we use linked binding in a module, then the scope only applies to binding the source, not to the target. For example, we have a class UserPref that implements both Professor and Student interfaces. This will create two instance of type: one for Professor and another one for Student:

bind(Professor.class).to(UserPref.class).in(Singleton.class);
bind(Student.class).to(UserPref.class).in(Singleton.class);

This is because the singleton scope applies at the binding type level, which is Professor and Student, not at the target type, UserPref.