Communicating to an Object from another without coupling in java?

Question

So I have a Person object, and a GumballMachine object. The behavior I'm searching for is, in the intent to avoid unnecessary coupling, have the method insertCoin() called from within the Person object, which will then call the insertCoin() within the GumballMachine to receive a Gumball.

What is a proper design-pattern, or solution that avoids coupling, and keeps these two objects as oblivious to each other as possible while having a type of "Bridge" between them?

Answer 1

To expand upon what Elliot was saying.

Your interface that returns true if the coin was accepted.

public interface Coinable {
    public boolean insertCoin();
}

Some person class that has some coins to insert into a Coinable interface.

public class Person {
    private int coins;

    public Person(int coins) {
        this.coins = coins;
    }

    public void insertCoin(Coinable cn) {
        if (this.coins <= 0) {
            System.out.println("You have no coins");
        } else {
            boolean coinAccepted = cn.insertCoin();
            if (coinAccepted) {
                coins--;
            }
        }
    }
}

And your GumballMachine that implements the Coinable interface.

class GumballMachine implements Coinable {
    private int gumBalls;

    public GumballMachine(int gumBalls) {
        this.gumBalls = gumBalls;
    }

    @Override
    public boolean insertCoin() {
        if (gumBalls <= 0) {
            System.out.println("There are no gumballs left");
            return false;
        } else {
            System.out.println("A gumball was dispensed!");
            gumBalls--;
            return true;
        }
    }
}

And an example of how all this works

public static void main(String[] args) {
    Person p = new Person(3); // 3 coins
    GumballMachine g = new GumballMachine(2); // 2 gumballs 

    p.insertCoin(g);
    p.insertCoin(g);
    p.insertCoin(g); // out of gumballs

    g = new GumballMachine(2); // refill the machine, still have 1 coin
    p.insertCoin(g);
    p.insertCoin(g);
}

Output

A gumball was dispensed!
A gumball was dispensed!
There are no gumballs left
A gumball was dispensed!
You have no coins

Answer 2

Create an interface, say Coinable, with a single insertCoin() method.

interface Coinable {
    insertCoin();
}

Then you can make n Object(s) that implement Coinable (and, some may delegate). And by programming to the interface, you can use various instances interchangeably.

Answer 3

OK, here is a different take on the question.

An object oriented principle is to minimize coupling. I agree that it is often a good idea. But another important programming principle is to minimize complexity. The answer by cricket_007 does a good job of reducing coupling, but it does add more code. I don't know the specifics of your application, but there may be times when it is better to go with the simpler but more coupled code. This is especially true if the application is going to be fairly small.