Object interaction in Java - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is object interaction in Java?

Object interaction means how different objects in a program communicate and work together by calling each other's methods or accessing data.

beginner

How does one object call a method of another object in Java?

One object calls a method of another by using a reference to that object followed by a dot and the method name, like objectReference.methodName().

beginner

Why is object interaction important in programming?

It helps break complex problems into smaller parts where objects work together, making code easier to understand, reuse, and maintain.

intermediate

What role do constructors play in object interaction?

Constructors create and initialize objects so they are ready to interact with other objects by having proper data and state.

intermediate

Explain the difference between this and another object reference in object interaction.

this refers to the current object itself, while another object reference points to a different object that the current object can interact with.

How does an object in Java access another object's method?

A By declaring a new class

B Using the other object's reference and dot notation

C By copying the method code

D By using the 'new' keyword only

Objects interact by calling methods through references using dot notation, like obj.method().

What keyword refers to the current object inside its class?

A object

B self

C current

D this

The keyword this refers to the current object instance.

Which of these is NOT a way objects interact?

A Changing the Java language syntax

B Accessing other objects' data directly if accessible

C Creating new objects

D Calling methods on other objects

Changing the Java language syntax is not related to object interaction.

What is the purpose of a constructor in object interaction?

A To initialize objects for interaction

B To destroy objects

C To call methods on other objects

D To create variables

Constructors set up objects so they can properly interact with others.

If object A wants to use object B's method, what must object A have?

A A constructor named after object B

B The same class as object B

C A reference to object B

D A copy of object B's code

Object A needs a reference to object B to call its methods.

Describe how two objects in Java can interact with each other.

Think about how one object can use another object's abilities.

Explain the role of constructors in preparing objects for interaction.

Consider what happens when you make a new object.

Practice

1.

What does it mean when two objects in Java interact?

Choose the best explanation.

easy

A. One object calls a method of another object to perform a task.

B. Two objects share the same memory location.

C. Objects are created using the same class.

D. Objects are stored in the same variable.

Solution

1. Step 1: Understand object interaction meaning

   Object interaction means objects communicate by calling each other's methods to work together.

2. Step 2: Evaluate options

   Only One object calls a method of another object to perform a task. describes calling methods between objects, which is how interaction happens.

3. Final Answer:

   One object calls a method of another object to perform a task. -> Option A

4. Quick Check:

   Object interaction = method calls between objects [OK]

Hint: Objects interact by calling methods on each other [OK]

Common Mistakes:

• Thinking objects share memory to interact
• Confusing object creation with interaction
• Assuming variables store multiple objects

2.

Which of the following is the correct syntax to call a method start() on an object car in Java?

easy

A. start(car);

B. car.start();

C. car->start();

D. start.car();

Solution

1. Step 1: Recall Java method call syntax

   In Java, to call a method on an object, use objectName.methodName();.

2. Step 2: Check each option

   car.start(); matches correct syntax. Options A, B, and C are invalid Java syntax.

3. Final Answer:

   car.start(); -> Option B

4. Quick Check:

   Method call = object.method() [OK]

Hint: Use objectName.methodName() to call methods [OK]

Common Mistakes:

• Using arrow (->) like in C++
• Reversing method and object order
• Calling method like a function with object as argument

3.

Consider the following Java code:

class Light {
    boolean isOn = false;
    void toggle() {
        isOn = !isOn;
    }
    boolean status() {
        return isOn;
    }
}

class Room {
    Light light = new Light();
    void switchLight() {
        light.toggle();
    }
    boolean lightStatus() {
        return light.status();
    }
}

public class Main {
    public static void main(String[] args) {
        Room room = new Room();
        System.out.println(room.lightStatus());
        room.switchLight();
        System.out.println(room.lightStatus());
    }
}

What is the output when this program runs?

medium

A. false
true

B. true
false

C. false
false

D. true
true

Solution

1. Step 1: Check initial light status

   Initially, isOn is false, so room.lightStatus() prints false.

2. Step 2: Toggle light and check status again

   Calling room.switchLight() toggles isOn to true. Then room.lightStatus() prints true.

3. Final Answer:

   false true -> Option A

4. Quick Check:

   Initial false, toggled true = false then true [OK]

Hint: Track boolean changes step-by-step [OK]

Common Mistakes:

• Assuming toggle sets true first without initial check
• Confusing method calls and variable values
• Ignoring initial value of isOn

4.

Find the error in this Java code snippet involving object interaction:

class Printer {
    void print(String message) {
        System.out.println(message);
    }
}

public class Main {
    public static void main(String[] args) {
        Printer printer;
        printer.print("Hello World");
    }
}

medium

A. The print statement syntax is incorrect.

B. The method 'print' is not defined in the Printer class.

C. The object 'printer' is declared but not initialized before use.

D. The class Printer should be public.

Solution

1. Step 1: Check object declaration and initialization

   The object 'printer' is declared but never assigned a new Printer instance.

2. Step 2: Understand consequences of uninitialized object

   Calling a method on an uninitialized object causes a NullPointerException at runtime.

3. Final Answer:

   The object 'printer' is declared but not initialized before use. -> Option C

4. Quick Check:

   Uninitialized object causes runtime error [OK]

Hint: Always initialize objects before calling methods [OK]

Common Mistakes:

• Assuming declaration equals initialization
• Thinking method absence causes error here
• Ignoring runtime NullPointerException

5.

You have two classes, BankAccount and Customer. A Customer has a BankAccount object. You want to add a method transferTo in BankAccount that transfers money to another BankAccount. Which of the following best shows how objects interact to perform this transfer?

class BankAccount {
    double balance;
    void deposit(double amount) { balance += amount; }
    void withdraw(double amount) { balance -= amount; }
    void transferTo(BankAccount other, double amount) {
        // Fill in this method
    }
}

class Customer {
    BankAccount account = new BankAccount();
}

hard

A. deposit(amount); withdraw(amount);

B. other.withdraw(amount); deposit(amount);

C. balance -= amount; other.balance += amount;

D. withdraw(amount); other.deposit(amount);

Solution

1. Step 1: Understand transfer logic

   To transfer money, withdraw from current account and deposit into the other account.

2. Step 2: Check method calls for interaction

   Calling withdraw(amount) on this object and deposit(amount) on the other object shows interaction.

3. Final Answer:

   withdraw(amount); other.deposit(amount); -> Option D

4. Quick Check:

   Transfer = withdraw from one, deposit to another [OK]

Hint: Transfer = withdraw from self, deposit to other [OK]

Common Mistakes:

• Withdrawing from the wrong account
• Directly changing balance without methods
• Depositing before withdrawing