Supongamos que tengo 3 clases: A, B y C, y que la clase A tiene un metodo: getB(), que devuelve un objeto de la clase B, y que B tambien tiene un metodo, getC(), que devuelve un objeto de la clase C.

Si hiciera lo siguiente:

A a = new A();
B b = a.getB();
C c = b.getC();

Tendria que importar la clase A,B y C. Sin embargo, si yo hiciera esto:

A a = new A();
C c = a.getB().getC();

No tendria que importar la clase B. ¿Por que?
Si es porque la clase B ya importa la clase C, entonces ¿Por que en el primer caso tengo que importarla si ya viene incluida al incluir C?

EDIT:Voy a poner la definición de las clases A, B y C para que me entendáis mejor:

package paquete_a;
 
import paquete_b.B;
 
public class A{
    public B getB(){
        return new B();
    }
}

package paquete_b;
 
import paquete_c.C;
 
public class B{
    public C getC(){
        return new C();
    }
}

package paquete_c;
 
public class C{
    //Esta clase no tiene nada
}

package test;
 
import paquete_a.A;
import paquete_b.B;
import paquete_c.C;
 
public class Test_1{
    public static void main(String[] args){
        A a = new A();
        B b = a.getB();
        C c = b.getC();
    }
}

package test;
 
import paquete_a.A;
//No es necesaria la importación de la clase B
import paquete_c.C;
 
public class Test_2{
    public static void main(String[] args){
        A a = new A();
        C c = a.getB().getC();
    }
}

EDIT 2: Vamos a suponer que en C++ tenemos 3 archivos headers (esos que tienen la extension ".h"): Uno para la clase A, otro para la clase B y otro para la clase C, que basicamente seran iguales que las clases que acabo de mostrar, pero con la unica diferencia de que estan escritos en C++. Supongamos tambien que tenemos 2 archivos: test1.cpp y test2.cpp, que solo tienen un metodo main que simplemente hacen lo mismo que el metodo main de la clase Test_1 y Test_2 de java que he mostrado antes para ver como seria un ejemplo. Bueno pues en C++ cuando tu incluyes un archivo (En este caso, algo como #include A.h ó #include B.h) lo que realmente pasa es que se "inserta" tal cual el archivo encima de aquel en el que lo incluyes, de modo que si un archivo solo tiene el siguiente codigo:

#include <stdio.h>
 
int main(

y otro incluye al anterior y solo tiene el siguiente codigo:

){
    printf("Hola Mundo");
}

Compilará sin problemas y si ejecutamos nos mostrará el mensaje "Hola Mundo".
Ahora bien, si en el archivo que contiene la clase A incluyo el archivo de la clase B, y en el archivo que contiene la clase B incluyo el archivo que contiene la clase C, entonces el resultado seria el mismo que si hubiese creado un archivo con las 3 clases. Si en el archivo test1.cpp incluyo el archivo que contiene la clase A, entonces nisiquiera tendre que incluir el archivo que contiene la clase C para que el codigo equivalente de C++ de este trozo de codigo

    A a = new A();
    B b = a.getB();
    C c = b.getC();

Se pueda compilar y ejecutar sin problemas. Sin embargo con java no pasa esto, sino que algunas veces (Como el primer caso que muestro arriba del todo) hay que importar la clase B, y en otros (Como el ejemplo de codigo que viene inmediatamente despues) no es necesario para ejecutar getC(). ¿Por que? ¿Por que unas veces si y otras veces no?

Como ha comentado miltonprogramador, si dejas un ejemplo practico del cual viene tu duda podriamos darte una axplicacion.  Ya que por ejemplo:

A a = new A();
C c = a.getB().getC();

No es posible si declaras una funcion que retorne un objeto tipo String como en el siguiente ejemplo que dare.
Cuando llamas a la clase A, esta retorna un valor de la clase B con getB(), pero no puedes llamar a getC() ya que esa clase no contiene ningun metodo llamado de tal manera, ni mucho menos llamarlos de manera seguida.
Todo esto suponiendo que tengas algo asi:

class Ideone
{
	public static void main (String[] args)
	{
		A a = new A();
		B b = new B();
        System.out.print(a.getB() + b.getC());
	}
}
 
class A {
 
        public String getB() {
        B b = new B();
        return b.B;
    }
}
 
class B {
 
    public String B = "B";
    public String getC() {
        C c = new C();
        return c.C;
    }
}
 
class C {
 
    public String C = "C";
}
 

Eso sigue el esquema que tu has dicho, A retorna el valor de B, y B el de C, pero como digo, no puedes llamar ahi a A y retornar el valor de C, para ello has de hacer como has puesto en el primer ejemplo que has dado.
Otra alternativa es la herencia, para hacer uso de atributos y metodos de la clase heredada.

No es obligatorio importar el paquete de la clase B cuando llamas al metodo getB()

package test;
 
import paquete_a.A;
//No es necesaria la importación de la clase B
import paquete_c.C;
 
public class Test_2{
    public static void main(String[] args){
        A a = new A();
        a.getB();
    }
}

El anterior codigo es funcional pero no le puedes asignar a una variable de tipo B porque la actual clase no reconoce ese tipo de dato, miralo asi cuando llamas a getB() te retorna la referencia donde se encuentra el objeto pero no sabe de que tipo es, lo unico que puedes hacer es importar la clase a la que pertenece o  asginarlo a una variable de tipo Object que es la clase la cual todos los objetos heredan.

Todos los objetos al heredar de Object contiene el metodo getClass() con el cual se puede identificar a que clase pertenece

 public static void main(String[] args) {
       A a=new A();     
       System.out.println(a.getB().getClass());
    }
 

Ejecuta lo anterior el cual te mostrara la clase y el paquete al que pertenece el objeto

Como te mencione el metodo getClass() te regresa la clase y el paquete al que pertenece la clase pero al mismo tiempo nos das información de la clase en especifico como que métodos han sido declarados.

Para ello usamos la funcion getDeclaredMethods() que viene en el metodo getClass() y si utiliza "Reflection".

 public static void main(String[] args) {
       A a=new A();     
       for(Method current :a.getB().getClass().getDeclaredMethods()){
           System.out.println(current.getName());
       }
    }