AP Computer Science a Quiz: This Keyword

What this quiz covers

This quiz focuses on This Keyword, giving you a quick way to practice the rules, question types, and explanations that matter most for AP Computer Science a.

How to use this quiz

Try each quiz question before looking at the correct answer. Use the explanations to review missed ideas, then come back to similar questions until the pattern feels familiar.

Question 1

public static void incrementShared()
{
    // Line 1
    sharedCount++;
    // Line 2
    this.instanceCount++;
    // Line 3
}
// other methods not shown

1. It will compile without error.
2. It will cause a compile-time error at Line 1.
3. It will cause a compile-time error at Line 2. (correct answer)
4. It will cause a run-time error when called.

Explanation: The incrementShared method is a static method, meaning it belongs to the class itself, not to any specific instance (object). The this keyword is a reference to the current object instance. Since there is no object instance in a static context, this cannot be used, resulting in a compile-time error.

Question 2

public void setLocation(int x, int y)
{
    /* missing code */
}

1. this.x = x; this.y = y;
2. x = x; y = y; (correct answer)
3. this.x = x; y = this.y;
4. this.y = y; x = this.x;

Explanation: In the statements x = x; and y = y;, the variable name on the left side of the assignment refers to the parameter, not the instance variable. The instance variables are shadowed. This code assigns the parameters' values to themselves, leaving the instance variables unchanged.

Question 3

public boolean isAuthor(String author)
{
    return this.author.equals(author);
}

1. The suggestion is correct and is a more efficient implementation.
2. The suggestion will cause a compile-time error because a variable cannot be compared to itself.
3. The suggestion will compile but will always return true, which is incorrect. (correct answer)
4. The suggestion will compile but will compare the instance variable to itself, which is incorrect.

Explanation: In the expression author.equals(author), both occurrences of author refer to the method's parameter, as it shadows the instance variable. A string is always equal to itself, so this method would always return true, regardless of the actual author of the report. The original implementation using this.author is correct.

Question 4

public void joinTeam(Team t)
{
    // missing code
}

1. t.addPlayer(this); (correct answer)
2. t.addPlayer(Player);
3. this.addPlayer(t);
4. addPlayer(this);

Explanation: The this keyword refers to the current Player object. To add this player to team t, the addPlayer method must be called on the t object, passing the current player object (this) as the argument.

Question 5

class Rectangle {
    private int length;
    private int width;

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

    public void printArea() {
        System.out.println(this.length * this.width);
    }
}

1. It replaces local variables by making parameters instance variables.
2. It distinguishes the current object's fields from same-named parameters. (correct answer)
3. It allows this.length in any static context without an object.
4. It acts like super to access inherited length and width values.

Explanation: This question tests AP Computer Science A skills in using the 'this' keyword for class creation and instance management. In Java, the 'this' keyword is used within an instance method or constructor to refer to the current object, resolving ambiguities between instance variables and parameters. In the Rectangle class definition, 'this' solves the critical problem of distinguishing between constructor parameters named 'length' and 'width' and the instance variables with identical names. Choice B is correct because it accurately describes how 'this' distinguishes the current object's fields from same-named parameters, preventing the common error of parameter self-assignment. Choice C is incorrect because it fundamentally misunderstands 'this' - the keyword is strictly for instance contexts and cannot be used in static methods. To reinforce this concept, have students experiment with removing 'this' from assignments to see how it breaks initialization. Use IDE features to show how 'this.length' refers to the field while 'length' alone refers to the parameter in the constructor scope.

Question 6

class Rectangle {
    private int length;
    private int width;

    public Rectangle(int length, int width) {
        // 'this' distinguishes instance variables from parameters
        this.length = length;
        this.width = width;
    }

    public int area() {
        // method call on the current object
        return this.computeArea();
    }

    private int computeArea() {
        return length * width;
    }
}

1. It allows 'length' and 'width' to be used as global variables across all classes.
2. It refers to the current object, preventing parameter-field name collisions in assignments. (correct answer)
3. It modifies the method signature so area automatically receives length and width.
4. It can be used in static methods, so computeArea runs without an object.

Explanation: This question tests AP Computer Science A skills in using the 'this' keyword for class creation and instance management. In Java, the 'this' keyword is used within an instance method or constructor to refer to the current object, resolving ambiguities between instance variables and parameters. In the provided Rectangle class definition, 'this' solves the critical problem of parameter-field name collisions by explicitly referring to the current object's instance variables when assigning values from constructor parameters. Choice B is correct because it accurately describes how 'this' prevents parameter-field name collisions in assignments, ensuring proper initialization. Choice A is incorrect because 'this' doesn't make variables global - it specifically refers to instance variables of the current object only. To help students, reinforce the role of 'this' in object-oriented programming, emphasizing its necessity in constructors and methods. Use exercises that require resolving variable-parameter conflicts and demonstrate 'this' in various class scenarios.

Question 7

class Student {
    private String name;
    private int grade;

    public Student(String name, int grade) {
        this.name = name;
        this.grade = grade;
        this.printDetails(); // explicit call on current object
    }

    public void printDetails() {
        System.out.println(this.name + " has grade " + this.grade);
    }
}

1. It calls printDetails on the current object instance. (correct answer)
2. It calls printDetails on the Student class as a static method.
3. It calls printDetails on the superclass of Student.
4. It passes name and grade as new method parameters automatically.

Explanation: This question tests AP Computer Science A skills in using the 'this' keyword for class creation and instance management. In Java, the 'this' keyword is used within an instance method or constructor to refer to the current object, resolving ambiguities between instance variables and parameters. In the Student class, 'this.printDetails()' explicitly calls the printDetails method on the current object instance being constructed, though the 'this' is optional when invoking methods. Choice A is correct because it accurately identifies that 'this' calls printDetails on the current object instance, not on the class or superclass. Choice B is incorrect because it suggests a static method call, but 'this' can only be used in instance contexts and printDetails is an instance method. To help students understand method invocation with 'this', demonstrate that 'this.printDetails()' and 'printDetails()' are equivalent in instance methods. Use exercises where students trace through object creation and method calls to see how 'this' always refers to the specific object being operated on.

Question 8

class Student {
    private String name;
    private int grade;

    public Student(String name, int grade) {
        this.name = name;
        this.grade = grade;
        this.printDetails();
    }

    public void printDetails() {
        System.out.println("Student: " + name + ", Grade: " + grade);
    }
}

1. It refers to the current object to set instance variables from parameters. (correct answer)
2. It refers to the Student class, so fields become class variables.
3. It accesses constructor parameters after they go out of scope.
4. It can be used the same way inside a static main method.

Explanation: This question tests AP Computer Science A skills in using the 'this' keyword for class creation and instance management. In Java, the 'this' keyword is used within an instance method or constructor to refer to the current object, resolving ambiguities between instance variables and parameters. In the Student constructor, 'this' refers to the current object being created, allowing 'this.name = name' to correctly assign the parameter value to the instance variable rather than to itself. Choice A is correct because it accurately states that 'this' refers to the current object to set instance variables from parameters. Choice B is incorrect because it confuses instance variables with class variables - 'this' always refers to a specific object instance, not the class itself. To help students grasp this concept, use memory diagrams showing how 'this' points to the object in heap memory during construction. Have students write constructors with intentional naming conflicts to practice when 'this' is required versus when it's optional.

Question 9

class Employee {
    private String name;
    private int id;

    public Employee(String name, int id) {
        this.name = name;
        this.id = id;
        this.display();
    }

    public void display() {
        System.out.println("Employee: " + this.name + " (" + this.id + ")");
    }
}

1. It changes display into a static method callable anywhere.
2. It distinguishes fields from same-named parameters in the current object. (correct answer)
3. It refers to another Employee object passed into the constructor.
4. It allows using instance variables inside static contexts without objects.

Explanation: This question tests AP Computer Science A skills in using the 'this' keyword for class creation and instance management. In Java, the 'this' keyword is used within an instance method or constructor to refer to the current object, resolving ambiguities between instance variables and parameters. In the Employee class definition, 'this' solves the problem of having constructor parameters with the same names as instance variables, allowing proper initialization by distinguishing 'this.name' (the field) from 'name' (the parameter). Choice B is correct because it accurately identifies how 'this' distinguishes fields from same-named parameters in the current object. Choice D is incorrect because it fundamentally misunderstands 'this' - the keyword cannot be used in static contexts and doesn't allow instance variables in static methods. To reinforce understanding, use naming conflict scenarios in coding exercises and have students explain why 'name = name' fails while 'this.name = name' succeeds. Demonstrate with debugger tools how 'this' points to the specific object instance being constructed.

Question 10

class Car {
    private String brand;
    private String model;

    public Car(String brand, String model) {
        this.brand = brand;
        this.model = model;
        this.getDetails();
    }

    public String getDetails() {
        return this.brand + " " + this.model;
    }
}

1. It invokes getDetails on the current Car object instance. (correct answer)
2. It invokes getDetails on the Car class without an object.
3. It invokes getDetails on the superclass using dynamic binding.
4. It invokes getDetails on a different Car passed as a parameter.

Explanation: This question tests AP Computer Science A skills in using the 'this' keyword for class creation and instance management. In Java, the 'this' keyword is used within an instance method or constructor to refer to the current object, resolving ambiguities between instance variables and parameters. In the Car class, 'this.getDetails()' invokes the getDetails method on the current Car object instance being constructed, though the 'this' prefix is optional for method calls. Choice A is correct because it accurately identifies that 'this' invokes getDetails on the current Car object instance. Choice B is incorrect because it suggests a static method invocation, but 'this' can only be used in instance contexts and cannot invoke methods without an object. To help students understand method invocation, demonstrate that 'this.getDetails()' and 'getDetails()' are equivalent when calling instance methods from within the same object. Use tracing exercises to show how 'this' always refers to the specific object on which the constructor or method is being called.

Question 11

public Book(String title, String author)
{
    /* missing code */
}
// other methods not shown

1. this.title = title; this.author = author; (correct answer)
2. title = title; author = author;
3. this.title = this.title; this.author = this.author;
4. Book.title = title; Book.author = author;

Explanation: The this keyword is a reference to the current object. When a parameter name (e.g., title) is the same as an instance variable name, this.title must be used to refer to the instance variable, while title by itself refers to the parameter. This correctly assigns the parameter values to the instance variables.

Question 12

public Student(int studentID)
{
    studentID = studentID;
}

public int getStudentID()
{
    return studentID;
}

1. 12345
2. 0 (correct answer)
3. null
4. The code will not compile.

Explanation: In the constructor, the statement studentID = studentID; assigns the value of the parameter studentID to itself. The instance variable studentID is shadowed by the parameter and is never assigned a value. Therefore, the instance variable retains its default value, which is 0 for an int.

Question 13

public Box(int w) { this.width = w; }

public boolean isSameSize(Box other)
{
    return this.width == other.width;
}

1. The Box object passed as the parameter other.
2. The Box class itself.
3. The Box object on which the isSameSize method was invoked. (correct answer)
4. A new Box object that is created when the method is called.

Explanation: In an instance method, this is always a reference to the object that the method was called on. For example, in the call b1.isSameSize(b2), this would refer to b1.

Question 14

public boolean isSameObject(Gadget other)
{
    return /* expression */ ;
}

1. this == other (correct answer)
2. this.equals(other)
3. this.id == other.id
4. Gadget.this == Gadget.other

Explanation: The equality operator == when used with object references, compares their memory addresses. this == other will be true only if both this and other refer to the same object in memory. The equals method typically checks for logical equality (e.g., same ID), not object identity.

Question 15

public Chainable setValue(int value)
{
    this.value = value;
    /* missing return statement */
}

1. return this; (correct answer)
2. return new Chainable();
3. return value;
4. return Chainable;

Explanation: To return the current object, the this keyword is used. return this; returns a reference to the same object the method was called on, enabling method chaining. Returning a new object would break the chain on the original object.

Question 16

public void setTemperature(double newTemp)
{
    temperature = newTemp;
}

public void adjustTemperature(double newTemp)
{
    this.temperature = newTemp;
}

1. Only setTemperature will compile because this cannot be used with method parameters.
2. Only adjustTemperature will compile because this is required to change an instance variable.
3. Both methods will compile and have the exact same functionality. (correct answer)
4. Both methods will compile, but adjustTemperature is more efficient.

Explanation: The this keyword is only required to disambiguate an instance variable from a local variable or parameter with the same name. In this case, the parameter newTemp has a different name than the instance variable temperature. Therefore, this is optional, and both temperature = newTemp; and this.temperature = newTemp; are valid and functionally identical.

Question 17

public Person getOlder() {
    this.age++;
    return this;
}

1. personA == personB (correct answer)
2. personA.getAge() == 30
3. personB.getAge() == 30
4. personA.equals(null)

Explanation: The getOlder method returns this, which is a reference to the object the method was called on (in this case, personA). Therefore, after the call, both personA and personB hold a reference to the same object in memory. The == operator confirms this object identity. The age of this single object becomes 31.

Question 18

public Client(Service s)
{
    myService = s;
}

public void performRegistration()
{
    myService.register(/* argument */);
}

1. new Client(myService)
2. Client
3. this (correct answer)
4. myService

Explanation: The register method of the Service class expects a Client object as its parameter. Within the performRegistration instance method, this is a reference to the current Client object. Therefore, passing this provides the Service object with the correct Client to register.

Question 19

public Logger getSelf() {
    return this;
}

public Logger getNew() {
    return new Logger("new");
}

1. log1 == log2 is true and log1 == log3 is true.
2. log1 == log2 is true and log1 == log3 is false. (correct answer)
3. log1 == log2 is false and log1 == log3 is true.
4. log1 == log2 is false and log1 == log3 is false.

Explanation: The getSelf method returns this, so log2 will refer to the exact same object as log1. The getNew method uses the new keyword to create a completely new and distinct Logger object. Therefore, log1 == log2 is true because they point to the same object, but log1 == log3 is false because they point to different objects.

Question 20

public Message(String content)
{
    this.content = content;
}

public void sendTo(Destination d)
{
    d.receive(this);
}

1. To create a new copy of the Message object to send to the destination.
2. To pass a reference to the current Message object to the destination. (correct answer)
3. To pass the String content of the message directly to the destination.
4. To indicate that the receive method is part of the Message class.

Explanation: The receive method of the Destination class requires a Message object as its parameter. The this keyword inside the sendTo method is a reference to the Message object on which sendTo was called. Using this as the argument passes the current message object itself to the destination's receive method.