this Keyword

You have written one class and then created several objects from it. Each object has its own copy of every instance variable (Topic 3.3). But the code for a method is written only once, inside the class. When that one piece of code says seat, how does Java know whose seat it means? And what if a method needs to talk about “the object I belong to” as a whole, not just one of its variables?

The answer starts with how you call an instance method. In Topic 3.5 you wrote calls such as hit.report(). The variable before the dot holds a reference to one particular object, and the method runs for that object. While it runs, that object is the one in charge, like the person holding the microphone at a meeting. Anyone at the meeting can say “I”, and “I” always means whoever is holding the microphone right now.

Java gives every instance method and every constructor a built-in way to say “I”. That way is the keyword this. Think of it as a variable you never declare, which stores a reference to the current object: whichever object the running method was called on, or the new object a running constructor is setting up. You also never assign to it. Java fills it in automatically at the start of each call with the reference that was used to make the call. (Here the microphone analogy stops working: at a meeting people grab the microphone whenever they like, but in Java the call itself decides who holds it, every single time.)

Here is the syntax taken apart:

class Ticket
{
    private String seat;

    public Ticket(String seatCode)
    {
        seat = seatCode;
    }

    public void describe()
    {
        System.out.println("Seat " + this.seat);
    }
}

public class SeatTicket
{
    public static void main(String[] args)
    {
        Ticket front = new Ticket("A1");
        Ticket back = new Ticket("K9");
        back.describe();
        front.describe();
    }
}

Seat K9
Seat A1

The table above claims that this holds the same reference as the variable in front of the dot. You can test that claim directly. In Topic 2.6 you learned that == on two references is true only when they refer to the very same object. The next class compares this with a parameter.

class Ticket
{
    private String seat;

    public Ticket(String seatCode)
    {
        seat = seatCode;
    }

    public boolean isSameAs(Ticket other)
    {
        return this == other;
    }
}

public class SameTicket
{
    public static void main(String[] args)
    {
        Ticket front = new Ticket("A1");
        Ticket back = new Ticket("K9");
        Ticket myTicket = back;
        System.out.println(front.isSameAs(front));
        System.out.println(front.isSameAs(back));
        System.out.println(back.isSameAs(myTicket));
    }
}

true
false
true

You may have noticed that the Ticket constructor on line 7 writes plain seat, not this.seat, and it works. That is because Java quietly treats a plain instance variable name inside an instance method as this.seat. Writing this. out is optional when nothing else has the same name. You will see in 3.9.2 when it stops being optional.

class Pedometer
{
    private int steps;

    public Pedometer(int start)
    {
        steps = start;
    }

    public void walk(int amount)
    {
        this.steps = this.steps + amount;
    }

    public int getSteps()
    {
        return this.steps;
    }
}

public class StepCounter
{
    public static void main(String[] args)
    {
        Pedometer mia = new Pedometer(100);
        Pedometer leo = new Pedometer(50);
        leo.walk(30);
        mia.walk(5);
        leo.walk(10);
        System.out.println(mia.getSteps());
        System.out.println(leo.getSteps());
    }
}

105
90

In Topic 3.8 you learned a rule about names: when a parameter or local variable has the same name as an instance variable, that name means the parameter or local variable inside the method. Programmers like to give constructor parameters the same names as the instance variables they fill, because title is the clearest name for both. But the 3.8 rule then gets in the way. Here is what happens:

class Song
{
    private String title;
    private int plays;

    public Song(String title, int plays)
    {
        title = title;
        plays = plays;
    }

    public String getTitle()
    {
        return title;
    }

    public int getPlays()
    {
        return plays;
    }
}

public class ShadowBug
{
    public static void main(String[] args)
    {
        Song hit = new Song("Sunrise", 12);
        System.out.println(hit.getTitle());
        System.out.println(hit.getPlays());
    }
}

null
0

The program compiles and runs, but the song has no title and no plays. On line 8, both names title mean the parameter title, so the line copies the parameter into itself. The same thing happens to plays on line 9. The instance variables are never touched, so they keep their default values from Topic 3.4: null for a String and 0 for an int.

When a local name hides an instance variable like this, we say the instance variable is shadowed. A plain name can no longer reach it. But this can: this.title always means “the current object’s title”, because the dot tells Java to look inside an object, and parameters do not live inside objects.

class Song
{
    private String title;
    private int plays;

    public Song(String title, int plays)
    {
        this.title = title;
        this.plays = plays;
    }

    public String getTitle()
    {
        return title;
    }

    public int getPlays()
    {
        return plays;
    }
}

public class ShadowFixed
{
    public static void main(String[] args)
    {
        Song hit = new Song("Sunrise", 12);
        System.out.println(hit.getTitle());
        System.out.println(hit.getPlays());
    }
}

Sunrise
12

Shadowing is not only a constructor problem. A method can have a parameter with an instance variable’s name too, and then a single expression can use both. That is where this shows its value most clearly.

class Song
{
    private String title;
    private int plays;

    public Song(String title, int plays)
    {
        this.title = title;
        this.plays = plays;
    }

    public void addPlays(int plays)
    {
        this.plays = this.plays + plays;
    }

    public void report()
    {
        System.out.println(title + ": " + plays);
    }
}

public class SongPlays
{
    public static void main(String[] args)
    {
        Song hit = new Song("Sunrise", 12);
        hit.addPlays(5);
        hit.report();
        hit.addPlays(3);
        hit.report();
    }
}

Sunrise: 17
Sunrise: 20

class Song
{
    private String title;
    private int plays;

    public Song(String title, int plays)
    {
        title = this.title;
        this.plays = plays;
    }

    public void addPlays(int plays)
    {
        this.plays = this.plays + plays;
    }

    public void report()
    {
        System.out.println(title + ": " + plays);
    }
}

public class ReversedThis
{
    public static void main(String[] args)
    {
        Song hit = new Song("Sunrise", 12);
        hit.addPlays(5);
        hit.report();
        hit.addPlays(3);
        hit.report();
    }
}

null: 17
null: 20

class Player
{
    private String name;
    private int level;

    public Player(String name, int level)
    {
        name = name;
        this.level = level;
    }

    public void show()
    {
        System.out.println(name + " is at level " + level);
    }
}

public class PlayerBug
{
    public static void main(String[] args)
    {
        Player hero = new Player("Zara", 3);
        hero.show();
    }
}

        this.name = name;

class Thermostat
{
    private int target;

    public Thermostat(int target)
    {
        this.target = target;
    }

    public void raise(int amount)
    {
        int target = this.target + amount;
        System.out.println("New target: " + target);
    }

    public int getTarget()
    {
        return target;
    }
}

public class ThermostatRaise
{
    public static void main(String[] args)
    {
        Thermostat hall = new Thermostat(68);
        hall.raise(4);
        System.out.println(hall.getTarget());
    }
}

So far this has been a way to reach the current object’s own variables. Sometimes a method needs to hand the whole current object to someone else. Think of a pet going to the vet. The pet’s visit method needs to call the vet’s examine method, and examine needs to know which pet it is examining. Inside visit, there is no variable named rex or luna; the method does not know what the caller named the object. What it does have is this.

Recall from Topic 3.6 that when an argument is a reference, the parameter receives a copy of that reference, not a copy of the object. So passing this gives the other method a reference to the current object itself. Whatever that method does through its parameter happens to the current object.

class Vet
{
    private String vetName;

    public Vet(String vetName)
    {
        this.vetName = vetName;
    }

    public void examine(Pet patient)
    {
        System.out.println(vetName + " examines " + patient.getName());
        patient.markHealthy();
    }
}

class Pet
{
    private String name;
    private boolean healthy;

    public Pet(String name)
    {
        this.name = name;
        healthy = false;
    }

    public String getName()
    {
        return name;
    }

    public boolean isHealthy()
    {
        return healthy;
    }

    public void markHealthy()
    {
        healthy = true;
    }

    public void visit(Vet doctor)
    {
        doctor.examine(this);
    }
}

public class VetVisit
{
    public static void main(String[] args)
    {
        Pet rex = new Pet("Rex");
        Pet luna = new Pet("Luna");
        Vet ortiz = new Vet("Dr. Ortiz");
        rex.visit(ortiz);
        System.out.println(rex.isHealthy());
        System.out.println(luna.isHealthy());
    }
}

Dr. Ortiz examines Rex
true
false

The other method does not have to be in a different class. Here a Rectangle passes itself to another Rectangle, so one comparison method can be reused to build a second one.

class Rectangle
{
    private int width;
    private int height;

    public Rectangle(int width, int height)
    {
        this.width = width;
        this.height = height;
    }

    public int area()
    {
        return width * height;
    }

    public boolean isLargerThan(Rectangle other)
    {
        return this.area() > other.area();
    }

    public boolean isSmallerThan(Rectangle other)
    {
        return other.isLargerThan(this);
    }
}

public class RectangleCompare
{
    public static void main(String[] args)
    {
        Rectangle poster = new Rectangle(4, 6);
        Rectangle card = new Rectangle(3, 5);
        System.out.println(card.isSmallerThan(poster));
        System.out.println(poster.isSmallerThan(card));
    }
}

true
false

class Vet
{
    private String vetName;

    public Vet(String vetName)
    {
        this.vetName = vetName;
    }

    public void examine(Pet patient)
    {
        System.out.println(vetName + " examines " + patient.getName());
        patient.markHealthy();
    }
}

class Pet
{
    private String name;
    private boolean healthy;

    public Pet(String name)
    {
        this.name = name;
        healthy = false;
    }

    public String getName()
    {
        return name;
    }

    public boolean isHealthy()
    {
        return healthy;
    }

    public void markHealthy()
    {
        healthy = true;
    }

    public void visit(Vet doctor)
    {
        doctor.examine(new Pet(name));
    }
}

public class VisitCopyBug
{
    public static void main(String[] args)
    {
        Pet rex = new Pet("Rex");
        Pet luna = new Pet("Luna");
        Vet ortiz = new Vet("Dr. Ortiz");
        rex.visit(ortiz);
        System.out.println(rex.isHealthy());
        System.out.println(luna.isHealthy());
    }
}

Dr. Ortiz examines Rex
false
false

class Friend
{
    private String name;

    public Friend(String name)
    {
        this.name = name;
    }

    public String getName()
    {
        return name;
    }

    public void greet(Friend other)
    {
        System.out.println(name + " waves at " + other.getName());
        other.waveBack(this);
    }

    public void waveBack(Friend greeter)
    {
        System.out.println(name + " waves back at " + greeter.getName());
    }
}

public class FriendWave
{
    public static void main(String[] args)
    {
        Friend kai = new Friend("Kai");
        Friend noor = new Friend("Noor");
        noor.greet(kai);
        kai.greet(noor);
    }
}

Noor waves at Kai
Kai waves back at Noor
Kai waves at Noor
Noor waves back at Kai

In Topic 3.7 you wrote class methods, the methods marked static. They belong to the class as a whole and are usually called with the class name, as in Math.sqrt(16.0) or Ticket.getTicketsSold(). Ask the 3.9.1 question about such a call: which object is in charge while it runs? Look at the call. There is no object before the dot, only a class name. No object, no current object, and so nothing for this to hold.

That is why Java gives a class method no this at all. It also explains a rule you met in Topic 3.7: a class method cannot use instance variables or call instance methods directly. A plain instance variable name means this.name, and an instance method call with no dot means this.method(). Without a this, neither has an object to work on.

class Ticket
{
    private String seat;

    public Ticket(String seat)
    {
        this.seat = seat;
    }

    public static String getSeat()
    {
        return this.seat;
    }
}

public class StaticThisError
{
    public static void main(String[] args)
    {
        Ticket front = new Ticket("A1");
        System.out.println(Ticket.getSeat());
    }
}

StaticThisError.java:12: error: non-static variable this cannot be referenced from a static context
        return this.seat;
               ^
1 error

The next example shows what a class method can do: use class variables, and work with objects that are passed to it as parameters.

class Ticket
{
    private static int ticketsSold = 0;
    private String seat;

    public Ticket(String seat)
    {
        this.seat = seat;
        ticketsSold++;
    }

    public String getSeat()
    {
        return this.seat;
    }

    public static int getTicketsSold()
    {
        return ticketsSold;
    }

    public static boolean sameRow(Ticket first, Ticket second)
    {
        return first.seat.substring(0, 1).equals(second.seat.substring(0, 1));
    }
}

public class StaticWithParameter
{
    public static void main(String[] args)
    {
        Ticket front = new Ticket("A1");
        Ticket beside = new Ticket("A2");
        Ticket back = new Ticket("K9");
        System.out.println(Ticket.getTicketsSold());
        System.out.println(Ticket.sameRow(front, beside));
        System.out.println(Ticket.sameRow(front, back));
        System.out.println(back.getSeat());
    }
}

3
true
false
K9

Here is the comparison side by side:

public class MainThis
{
    private int score;

    public MainThis(int score)
    {
        this.score = score;
    }

    public int getScore()
    {
        return this.score;
    }

    public static void main(String[] args)
    {
        MainThis game = new MainThis(40);
        System.out.println(this.getScore());
    }
}

MainThis.java:18: error: non-static variable this cannot be referenced from a static context
        System.out.println(this.getScore());
                           ^
1 error

public class Lamp
{
    private int brightness;

    public Lamp(int brightness)
    {
        this.brightness = brightness;
    }
}

public class MainCallBug
{
    private int score;

    public MainCallBug(int score)
    {
        this.score = score;
    }

    public void printScore()
    {
        System.out.println("Score: " + score);
    }

    public static void main(String[] args)
    {
        MainCallBug game = new MainCallBug(40);
        printScore();
    }
}

MainCallBug.java:18: error: non-static method printScore() cannot be referenced from a static context
        printScore();
        ^

        game.printScore();

This bank account class uses every idea from the chapter: this. to reach shadowed instance variables in the constructor, this.balance in self-referencing expressions, this passed as an argument, and a class method that has no this. Before reading the trace, predict all five lines of output.

class BankAccount
{
    private static int accountsOpened = 0;
    private String owner;
    private int balance;

    public BankAccount(String owner, int balance)
    {
        this.owner = owner;
        this.balance = balance;
        accountsOpened++;
    }

    public String getOwner()
    {
        return owner;
    }

    public int getBalance()
    {
        return balance;
    }

    public void transferTo(BankAccount other, int amount)
    {
        this.balance = this.balance - amount;
        other.receive(this, amount);
    }

    public void receive(BankAccount sender, int amount)
    {
        this.balance = this.balance + amount;
        System.out.println(owner + " got " + amount + " from " + sender.getOwner());
    }

    public static int getAccountsOpened()
    {
        return accountsOpened;
    }
}

public class BankTransfer
{
    public static void main(String[] args)
    {
        BankAccount ana = new BankAccount("Ana", 100);
        BankAccount ben = new BankAccount("Ben", 20);
        ana.transferTo(ben, 30);
        ben.transferTo(ana, 5);
        System.out.println(ana.getBalance());
        System.out.println(ben.getBalance());
        System.out.println(BankAccount.getAccountsOpened());
    }
}

Ben got 30 from Ana
Ana got 5 from Ben
75
45
2

• Inside an instance method or a constructor, this holds a reference to the current object: the object before the dot in the call, or the object a constructor is building. It is set again at every call.
• A plain instance variable or instance method name inside an instance method means the same as writing this. in front of it.
• When a parameter or local variable shadows an instance variable, this.name reaches the instance variable; this.title = title; stores a parameter in the object. Forgetting this. compiles but leaves the instance variable unchanged.
• Passing this as an argument hands another method a reference to the current object, so that method can read or change the same object, not a copy.
• A class (static) method has no current object, so it has no this; using this or an instance member directly there, including in main, is a compile error. A class method can work with objects passed to it as parameters.

class Counter
{
    private int count;

    public Counter(int count)
    {
        this.count = count;
    }

    public Counter larger(Counter other)
    {
        if (this.count >= other.count)
        {
            return this;
        }
        return other;
    }

    public void increment()
    {
        count++;
    }

    public int getCount()
    {
        return count;
    }
}

public class LargerCounter
{
    public static void main(String[] args)
    {
        Counter red = new Counter(7);
        Counter blue = new Counter(9);
        Counter winner = red.larger(blue);
        winner.increment();
        Counter again = red.larger(red);
        again.increment();
        System.out.println(red.getCount());
        System.out.println(blue.getCount());
    }
}

8
10

class Vet
{
    private String vetName;

    public Vet(String vetName)
    {
        this.vetName = vetName;
    }

    public void examine(Pet patient)
    {
        System.out.println(vetName + " examines " + patient.getName());
        patient.markHealthy();
    }
}

class Pet
{
    private String name;
    private boolean healthy;

    public Pet(String name)
    {
        this.name = name;
        healthy = false;
    }

    public String getName()
    {
        return name;
    }

    public boolean isHealthy()
    {
        return healthy;
    }

    public void markHealthy()
    {
        healthy = true;
    }

    public void visit(Vet doctor)
    {
        doctor.examine(doctor);
    }
}

public class ExamineWrongArg
{
    public static void main(String[] args)
    {
        Pet rex = new Pet("Rex");
        Pet luna = new Pet("Luna");
        Vet ortiz = new Vet("Dr. Ortiz");
        rex.visit(ortiz);
        System.out.println(rex.isHealthy());
        System.out.println(luna.isHealthy());
    }
}

ExamineWrongArg.java:45: error: incompatible types: Vet cannot be converted to Pet
        doctor.examine(doctor);
                       ^

        doctor.examine(this);

BankAccount ben = new BankAccount("Ben", 20);
ben.transferTo(ben, 10);
System.out.println(ben.getBalance());

class Club
{
    private int members;
    private String newest;

    public Club()
    {
        members = 0;
        newest = "nobody";
    }

    public void join(Student s)
    {
        members++;
        newest = s.getName();
    }

    public void report()
    {
        System.out.println(members + " members, newest: " + newest);
    }
}

class Student
{
    private String name;

    public Student(String name, Club club)
    {
        this.name = name;
        club.join(this);
    }

    public String getName()
    {
        return name;
    }
}

public class ClubJoin
{
    public static void main(String[] args)
    {
        Club chess = new Club();
        chess.report();
        Student amir = new Student("Amir", chess);
        Student bea = new Student("Bea", chess);
        chess.report();
    }
}

0 members, newest: nobody
2 members, newest: Bea

public static boolean isFrontRow()
{
    return this.seat.substring(0, 1).equals("A");
}

• I can say which object this refers to for a given method call or constructor. Reread
• I can trace self-referencing expressions such as this.steps + amount and this == other. Reread
• I can use this to store a parameter in a shadowed instance variable, and spot code that forgets to. Reread
• I can trace code that passes this as an argument and explain why the called method changes the same object. Reread
• I can explain why a class method, including main, has no this, and fix code that uses it there. Reread