Ну мне циклы редко нужны. Если есть возможность обойти ограничение через что-то вроде void*, не думаю, что такой дизайн меня сильно бы ограничил. Правда непонятно из чего вытекает такое ограничение.

Вообще есть у нас есть класс A и класс B с методами a() и b(), которые, для простоты, рекурсивно вызывают друг друга, т.е. код вида:

class A {
    B b;
    void a() {
        b.b();
    }
}

class B {
    A a;
    void b() {
        a.a();
    }
}

То это разруливается через промежуточный интерфейс и становится нерекурсивным:

interface IA {
    void a();
}

interface IB {
    void b();
}

class A implements IA {
    IB b;
    void a() {
        b.b();
    }
}

class B implements IB {
    IA a;
    void b();
        a.a();
    }
}

При этом этот случай достаточно общий, чтобы такого подхода хватило на разруливание рекурсивной структуры типов любой степени сложности, насколько я могу представить. Иногда это даже может приводить к более чистому дизайну.

Ну мне циклы редко нужны. Если есть возможность обойти ограничение через что-то вроде void*, не думаю, что такой дизайн меня сильно бы ограничил. Правда непонятно из чего вытекает такое ограничение.

Вообще если у нас есть класс A и класс B с методами a() и b(), которые, для простоты, рекурсивно вызывают друг друга, т.е. код вида:

class A {
    B b;
    void a() {
        b.b();
    }
}

class B {
    A a;
    void b() {
        a.a();
    }
}

То это разруливается через промежуточный интерфейс и становится нерекурсивным:

interface IA {
    void a();
}

interface IB {
    void b();
}

class A implements IA {
    IB b;
    void a() {
        b.b();
    }
}

class B implements IB {
    IA a;
    void b();
        a.a();
    }
}

При этом этот случай достаточно общий, чтобы такого подхода хватило на разруливание рекурсивной структуры типов любой степени сложности, насколько я могу представить. Иногда это даже может приводить к более чистому дизайну.