@Component(modules = { ... })
public abstract class AppComponent {
    abstract public void inject(MainActivity mainActivity);
}

public final class DaggerAppComponent extends AppComponent {
  private DaggerAppComponent() {}

  public static Builder builder() {
    return new Builder();
  }

  @Override
  public void inject(MainActivity mainActivity) {
      ...
  }

  public static final class Builder {
    private Builder() {}

    public AppComponent build() {
      return new DaggerAppComponent();
    }
  }
}

public class MainActivity extends AppCompatActivity {
    AppComponent mAppComponent;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        ...
        mAppComponent = DaggerAppComponent.builder()
                .build();
        mAppComponent.inject(this);
    }
}

public final class DaggerAppComponent extends AppComponent {
  private final AppModule appModule;

  private DaggerAppComponent(AppModule appModuleParam) {
    this.appModule = appModuleParam;
  }

  public static Builder builder() {
    return new Builder();
  }

  public static AppComponent create() {
    return new Builder().build();
  }

  private CoffeeMaker getCoffeeMaker() {
    return AppModule_ProvideCoffeeMakerFactory.provideCoffeeMaker(
        appModule, new ElectricHeater(), new Pump());
  }

  @Override
  public void inject(MainActivity mainActivity) {
    injectMainActivity(mainActivity);
  }

  private MainActivity injectMainActivity(MainActivity instance) {
    MainActivity_MembersInjector.injectMCoffeeMaker(instance, getCoffeeMaker());
    return instance;
  }

  public static final class Builder {
    private AppModule appModule;

    private Builder() {}

    public Builder appModule(AppModule appModule) {
      this.appModule = Preconditions.checkNotNull(appModule);
      return this;
    }

    public AppComponent build() {
      if (appModule == null) {
        this.appModule = new AppModule();
      }
      return new DaggerAppComponent(appModule);
    }
  }
}

public class CoffeeMaker {
    private final Heater heater;
    private final Pump pump;
    private final Context context;

    public CoffeeMaker(Heater heater, Pump pump, Context context) {
        this.heater = heater;
        this.pump = pump;
        this.context = context;
    }

    public void brew() { ... }
}

@Module(includes = {SecondModule.class})
public class AppModule {

    Context context;

    public AppModule(Context context) {
        this.context = context;
    }

    @Provides
    public CoffeeMaker provideCoffeeMaker(Heater heater, Pump pump) {
        return new CoffeeMaker(heater, pump, context);
    }
}

public static final class Builder {
    private AppModule appModule;

    private Builder() {}

    public Builder appModule(AppModule appModule) {
      this.appModule = Preconditions.checkNotNull(appModule);
      return this;
    }

    public AppComponent build() {
      Preconditions.checkBuilderRequirement(appModule, AppModule.class);
      return new DaggerAppComponent(appModule);
    }
  }

mAppComponent = DaggerAppComponent.builder()
      .appModule(new AppModule(this))
      .build();

mAppComponent.inject(this);

@Component(modules = {AppModule.class})
public abstract class AppComponent {

    @Component.Builder
    public interface AppComponentBuilder {
        @BindsInstance
        public AppComponentBuilder builderContext(Context context);

        public AppComponent buildAppComponent();
    }

    abstract public void inject(MainActivity mainActivity);

}

public final class DaggerAppComponent extends AppComponent {
  private final Context builderContext;

  private final AppModule appModule;    // non-abstract module

  private DaggerAppComponent(AppModule appModuleParam, Context builderContextParam) {
    this.builderContext = builderContextParam;
    this.appModule = appModuleParam;
  }

  public static AppComponent.AppComponentBuilder builder() {
    return new Builder();
  }

  @Override
  public void inject(MainActivity mainActivity) { ...  }

  private static final class Builder implements AppComponent.AppComponentBuilder {
    private Context builderContext;

    @Override
    public Builder builderContext(Context context) {
      this.builderContext = Preconditions.checkNotNull(context);
      return this;
    }

    @Override
    public AppComponent buildAppComponent() {
      Preconditions.checkBuilderRequirement(builderContext, Context.class);
      return new DaggerAppComponent(new AppModule(), builderContext);
    }
  }
}