When to use static over passing reference in constructor for things I want to share?

A topic is not so clear I will try to explain my question in an easy example. We know what all clients of a bank share money from a bank. So if the bank is bankrupt, no client could take a loan. Based on that point of view I will try to make a simple program.

Approach 1:

    class Client {
        private static int sharedMoney = 100;
        void takeLoan(int amount) {
            sharedMoney = sharedMoney - amount;
        }
     }

Approach 2:

class Client {
    private SharedMoney sharedMoney;

    public Client(SharedMoney sharedMoney) {
        this.sharedMoney = sharedMoney;
    }

    void takeLoan(int amount) {
        sharedMoney.setAmount(sharedMoney.getAmount() - amount);
    }
}

class SharedMoney {
    private int amount;

    public SharedMoney(int amount) {
        this.amount = amount;
    }

    public int getAmount() {
        return amount;
    }

    public void setAmount(int amount) {
        this.amount = amount;
    }
}

Of course, logic is not 100% covered, but I think I showed my point. Does anyone have a rule of thumb I should follow when coding? When should I use static when sharing something (money) and when should I pass reference in the constructor when again sharing the same thing (money)?

In almost all cases approach 2 is preferred. This has a number of significant advantages over approach 1:

• It is much easier to test approach 2. You can pass in a mocked SharedMoney that behaves exactly as required for your test (such as having a specific amount of money).
• It allows you to add methods to the SharedMoney class that are related to those objects rather than end up with static methods in Client that aren't really related to that class's responsibilities
• Static variables contain global state. Global state is any program state that is potentially available to any code to access or change. Any time you have global state you introduce the possibility of an unrelated method changing that state with unexpected side effects which makes code unpredictable and prone to bugs that are difficult to detect. Try to avoid global state whenever possible. The alternative is generally dependency injection, of which your approach 2 is a good example.

These topics are dealt with at some length in the answers to https://stackoverflow.com/questions/7026507/why-are-static-variables-considered-evil Note, however, that at lot of the discussion there is really about mutable static variables. Constant values (generally declared as private static final and, by convention, given uppercase names) don't have the same disadvantages as their values can be relied upon not to change.