Encapsulation best practices in Java - Time & Space Complexity

Time Complexity: Encapsulation best practices

O(1)

Understanding Time Complexity

We want to see how the time it takes to run code changes when we use encapsulation in Java.

How does hiding data and controlling access affect the speed of our program?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

public class BankAccount {
    private double balance;

    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

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

    public double getBalance() {
        return balance;
    }
}
    

This code shows a simple bank account class that hides its balance and allows controlled access through methods.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Simple method calls to access or update the balance.
• How many times: Each method runs once per call; no loops or recursion inside these methods.

How Execution Grows With Input

Since each method does a fixed amount of work, the time does not grow with input size.

Input Size (n)	Approx. Operations
10	10 simple operations
100	100 simple operations
1000	1000 simple operations

Pattern observation: Time grows directly with the number of method calls, but each call is very fast and simple.

Final Time Complexity

Time Complexity: O(1)

This means each method runs in constant time, no matter the size of the data or how many times you use the class.

Common Mistake

[X] Wrong: "Encapsulation makes the program slower because it adds extra methods."

[OK] Correct: These methods do very simple work and run quickly, so they don't slow down the program noticeably.

Interview Connect

Understanding how encapsulation affects performance helps you write clean code that is also efficient, a skill valued in real projects and interviews.

Self-Check

"What if the deposit method included a loop to log each transaction? How would the time complexity change?"