Dagger2: How to inject field without injection of it's compositor class?

My Class A needs Dependency injection of Class C.
C class is component of B class (B has C as a field).
Can Class A inject C without B injection?

[A injected]->(B not injected to A)->[C injected to B]

I my real project I need to inject field to one class but don't need adding injection queue to the all classes contains (directly or indirectly) this field.

Currently I have Exception in B class:

Exception in thread "main" java.lang.NullPointerException
        at B.log(B.java:28)
        at A.b_foo(A.java:28)
        at App.main(App.java:36)

Please advice.
Code:

App.java

import dagger.Component;
import javax.inject.Singleton;
 
public class App {
  @Singleton
  @Component(
      modules = {
              CModule.class
             }
  )
  public interface AppRunner {
    A instance();
  }

  public static void main(String[] args) {
    AppRunner appRunner = DaggerApp_AppRunner.builder().build();
    appRunner.instance().foo();
  }
}

A.java

import javax.inject.Inject;

public class A {
    private final B b;

    @Inject
    A() {
        this.b = new B();
    }

    public void foo() {
        b.log();
    }
}

B.java

import javax.inject.Inject;

public class B {

  @Inject
  C c;

  B() { }

  public void log() {
      c.log("in C log"); //java.lang.NullPointerException here because B was not injected before C
  }
}

C.java

import javax.inject.Inject;
import javax.inject.Singleton;
import java.util.ArrayList;
import java.util.List;

@Singleton
public final class C {
  private final List<String> logs = new ArrayList<>();

  @Inject
  C() {}

  public void log(String msg) {
    logs.add(msg);
  }
}

CModule.java

import dagger.Module;
import dagger.Provides;

@Module
public abstract class CModule {
    @Provides
  static C provideC() {
        return new C();
    }
}

Update: Can I have fully working code without B injection at all? My A class knows about Dagger. But A must don't have B injection.

You have an @Inject field in class B, and you want to be able to get a fully initialized B within A

Option 1: Just add @Inject to the constructor

That's it. You don't need to move the dependencies into the constructor.

public class B {

  @Inject
  C c;

  @Inject // This annotation is the only thing added.
  B() { }

  public void log() {
      c.log("in C log");
  }
}

If even this is more than you want to change (or can change) in B, read on.

Option 2: Inject a MembersInjector<B>

Dagger contains the interface MembersInjector, which does exactly what it sounds like. You can inject MembersInjector<B> into A, and use that to construct B in two steps.

@Inject
A(MembersInjector<B> injector) {
    this.b = new B();
    injector.injectMembers(b);
}

Since MembersInjector is part of Dagger and not JSR-330, this means that class A necessarily has knowledge about Dagger. This is probably an issue, but you can easily move this logic out of A:

Option 3: Use MembersInjector in a @Provides method.

@Module
class BModule {
    @Provides
    static B provideB(MembersInjector<B> injector) {
        B b = new B();
        injector.injectMembers(b);
        return b;
    }
}

Now you can inject B or Provider<B> anywhere, without modifying B at all.