Java - how to make class 1 and class 2 both know about each other?

Question

I have a program I am in the middle of writing that is meant to simulate bugs finding food. In brief i have a grid (a world) in which there are bugs, obstacles and food of different energy values. Each bug will look in every direction, get the closest food within its "seeing distance" and move one cell towards it otherwise moving in a random direction.

I have 3 clases:

• ABug

• AWorld

• Main

ABug and AWorld obviously contain all the methods to populate a grid with food and obstacles, sense food, move a bug etc, and the Main class is the controller that creates a world, creates a number of bugs based on user input and adds them to the world.

My question is:

Is there a better way to make a bug know about a world it is in whilst a world also knows about the bugs in it other than passing a reference of the world into every function that needs it inside a bug?

I currently have an arraylist of bugs inside the world class and then pass the 2D array into the functions that need it in the bug class.

Sorry for the long explanation, wasnt sure how much detail people would want so I just put it all :)

Thanks for any suggestions

Answer 1

I would pass a reference to a World instance to every Bug Object either in the Bug constructor or in a setter Method. That way every bug instance knows it's respective world instance and can ask it about certain things (e.g. ask for food,...).

I would not make World a Singleton (definition see: http://en.wikipedia.org/wiki/Singleton_pattern). As there is no need and no use to limit yourself to exactly 1 instance of World. When used inappropriately Singleton pattern can limit the testability of your design, introduce subtle threading (and classloading) issues,...

Answer 2

Instead of passing World with every Bug-method as a parameter, you can also just do it once in a Bug's constructor and save it in a variable-field of ABug, like so:

In Main:

public static void main(String[] args){
    AWorld world = new AWorld(...);
    ABug[] bugs = new ABug[amount];
    for(int i = 0; i < amount; i++)
        bugs[0] = new ABug(..., world);
}

In ABug:

private AWorld world;

public ABug(..., AWorld w){
    this.world = w;
    ...
}

public void someMethodNeedingWorld(...){
    world.methodYouNeedFromWorld();
    ...
}

---

You can also try what #StackFlowed said and make AWorld a Singleton:

In AWorld:

private static AWorld instance;

private AWorld(){ } // private constructor for Singleton pattern

public static AWorld getInstance(){
    if(instance == null)
        instance = new AWorld();

    return instance;
}

In Main:

public static void main(String[] args){
    ABug[] bugs = new ABug[amount];
    for(int i = 0; i < amount; i++)
        bugs[0] = new ABug(...);
}

In ABug's methods where you need AWorld:

public void someMethodNeedingWorld(...){
    AWorld.getInstance().methodYouNeedFromWorld();
    ...
}

Personally I would go for the Singleton pattern, since this is what they are designed for. This also makes sure you only have a single AWorld instance during your entire application. (If you want to be able to create multiple Worlds at some state, I would suggest the first method.)

EDIT:

If you want to make future adjustments by having multiple AWorlds in the same application, or use UnitTests, the Singleton Pattern isn't a very good idea, since it can only work with 1 AWorld-instance at a time, doesn't matter if its a UnitTest or not. So in that case, I recommend the first option, by just sending the AWorld object to the ABug's constructor and saving it in ABug, instead of sending it as parameter with every method of ABug. Still, if you never want to use UnitTests or make adjustments (can't recommend that, but it's up to you..), the Singleton Pattern could be used here.