Question

I have two classes as such:

public class A{
    ArrayList<Runnable> classBList = new ArrayList<Runnable>();
    int x = 0;

    public A(){
        //This code here is in a loop so it gets called a variable number of times
        classBList.add(new B());
        new Thread(classBList.get(classBList.size())).start();
    }
}

public class B implements Runnable{
    public B(){

    }

    public void run(){
        //Does some things here. blah blah blah...
        x++;
    }
}

The problem is that I need to have the instance of class B change the variable x in class A, the class that created class B. However, I do not know how I would let class B know that it needs to change the value or if it can. Any suggestions on how to change it would be greatly appreciated. Thank you!

Answer 1

You need to give your B instance access to the A instance. There are a couple of ways to do that:

1. Make B derive from A and make the data fields (or accessors for them) protected in A. I would tend to shy away from this one.

2. Make B accept an A instance in its constructor.

3. Make B accept an instance of a class that implements some interface in its constructor, and have A implement that interface.

Which you choose is up to you. I’ve given them in roughly decreasing order of coupling, where the more loosely-coupled, the better (usually).

That third option in code:

public TheInterface {
    void changeState();
}

public class A implements TheInterface {
    ArrayList<Runnable> classBList = new ArrayList<Runnable>();
    int x = 0;

    public A(){
        //This code here is in a loop so it gets called a variable number of times
        classBList.add(new B(this)); // <=== Passing in `this` so `B` instance has access to it
        new Thread(classBList.get(classBList.size())).start();
    }

    // Implement the interface
    public void changeState() {
        // ...the state change here, for instance:
        x++;
    }
}

public class B implements Runnable{
    private TheInterface thing;

    public B(TheInterface theThing){
        thing = theThing;
    }

    public void run(){
        // Change the thing's state
        thing.changeState();
    }
}

Now, both A and B are coupled to TheInterface, but only A is coupled to B; B is not coupled to A.