Instance methods and this

Written Explanation

From data to behavior

An instance method is declared inside the class, like a field, but it has a body. The difference from the methods you wrote in the methods module is that it does not use static. Because it is not static, it runs on an object and has direct access to that object's fields.

void deposit(double amount) {
    balance += amount;
}

Look at what is missing: there is no account parameter and no a.balance. The method just says balance, and Java understands it as "the balance of the object this method was called on". You call it with the dot:

ana.deposit(50);   // changes ana's balance
omar.deposit(50);  // changes omar's balance, not ana's

The code of deposit exists once, in the class. The state it changes comes from whichever object is in front of the dot. That is the whole idea of object-oriented methods: behavior is shared, state is per object.

Return values

Instance methods can be void or return a value, exactly like the methods you know. A good rule: if the caller needs to know whether something worked or needs an answer, return it. Here withdraw answers "did it work?":

boolean withdraw(double amount) {
    if (amount > balance) {
        return false;       // not enough money: nothing changes
    }
    balance -= amount;
    return true;
}

And describe builds text from the object's own fields:

String describe() {
    return owner + " (" + number + "): " + balance;
}

Returning a String rather than printing inside the method keeps the method flexible. The caller decides whether to print it, log it, or send it over a network.

What this means

Inside an instance method or a constructor, this is a reference to the current object: the object whose method is running. The Java tutorial defines it that way. Written in full, deposit could be:

void deposit(double amount) {
    this.balance += amount;   // identical to: balance += amount;
}

Both forms do the same thing. this. is optional when there is no clash of names. When you call ana.deposit(50), this is ana; when you call omar.deposit(50), this is omar.

An instance method can also call another instance method of the same object. You can write describe() or this.describe(); both refer to the current object.

The bug: a parameter shadows a field

Suppose a parameter has the same name as a field, which is very common, because the best name for the owner you receive is owner. Inside the constructor, the plain name owner now refers to the parameter. The parameter shadows (hides) the field of the same name.

public class Shadow {
    String owner;
    Shadow(String owner) {
        owner = owner;      // assigns the parameter to itself
    }
}

The compiler accepts this, because assigning a variable to itself is legal. But nothing reaches the field. Creating new Shadow("Ana") and printing s.owner shows:

null

The fix is the pattern you have been using: this.owner = owner;. The left side is the field of the current object, the right side is the parameter. Remember the symptom: a field stays at its default (null, 0) even though you passed a value. Whenever you see that, check for a missing this.

Some programmers avoid shadowing by choosing a different parameter name, such as startOwner. Both approaches work. The convention in most Java code is to keep the same name and use this.

Instance versus static methods

You wrote static methods in the methods module, and main is one of them. A static method is called by class name and has no current object, so it has no this. An instance method is called on an object and has one. As a rule of thumb: if the method needs one object's data, it is an instance method. Lesson 5 compares the two properly; for now, write static only for main and for helpers that need no object.