how to avoid circular dependencies here

Question

Is there a way to avoid circular dependencies, other than mixing modules, in a arrangement like this(it is a chess application)

Long description:

Answer 1

I think the smell of a circular dependency shows more an architectural/design issue, that shouldn't be solved by DI, late bounding, loose coupling, or any other form of an extra abstraction layer. Although they are all very good mechanisms, but don't solve the problem underneath.

Short: I think the ChessWorld holds too many responsibilities. If you split them up you'll probably will find that the dependencies are responsibilities better suited in a separate module.

Long explanation: I'll try to give an example of how I would refactor it, although it's hard because I don't really now the full problem domain.

NOTE: I am not familiar with Java so I may misunderstand the implications of import and wrap.

But as I understand the dependencies look somewhat like this:

Gui <- ChessWidget <- ChessWorld <- CellButton <- Cell
                                 <- Board <- Piece <- Player
                                 <- Players <- ChessWorld

IMHO the problem is that ChessWorld holds too many different responsibilities. Maintaining the list of players is probably better in a separate module like PlayerList, RegisteredUsers or OnlineUsers or something similar. After that refactoring your depedencies would change as follows:

 Gui <- ChessWidget <- ChessWorld <- CellButton <- Cell
                                  <- Board <- Piece <- Player
                                  <- Playerlist <- Player

PlayerList is probably something you would have in the player module. Now Chessworld depends on the player module and not in the other direction.

I am not sure if it fits your intention perfectly, but I am very interested in discussing this, so please comment.