Encapsulation best practices in Java - Step-by-Step Execution

Concept Flow - Encapsulation best practices

Define private fields

↓

Create public getters/setters

↓

Control access to fields

↓

Use methods to validate or modify data

↓

Hide internal details from outside

↓

Allow safe interaction only

Encapsulation means keeping data private and controlling access through methods to protect and manage it safely.

Execution Sample

Java

public class Person {
  private String name;
  public String getName() { return name; }
  public void setName(String name) {
    if(name != null && !name.isEmpty()) this.name = name;
  }
}

This code shows a class with a private field and public methods to safely access and change it.

Execution Table

Step	Action	Field 'name' Value	Condition Checked	Result
1	Create Person object	null	N/A	Object created, name is null
2	Call setName("")	null	name != null && !name.isEmpty() is false	name not changed
3	Call setName("Alice")	null -> "Alice"	name != null && !name.isEmpty() is true	name set to "Alice"
4	Call getName()	"Alice"	N/A	Returns "Alice"

💡 No more actions, encapsulation protects 'name' from invalid values

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
name	null	null	"Alice"	"Alice"

Key Moments - 3 Insights

Why can't we access 'name' directly from outside the class?

Because 'name' is private, only methods inside the class can access it, as shown in step 1 and 2 of the execution_table.

What happens if we try to set 'name' to an empty string?

The setter method checks the condition and refuses to change 'name', so it stays null as seen in step 2.

How does the getter method help us?

It allows safe read access to 'name' without letting outside code change it directly, shown in step 4.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'name' after step 2?

A null

B "" (empty string)

C "Alice"

D undefined

💡 Hint

Check the 'Field name Value' column at step 2 in the execution_table

At which step does the condition in setName allow changing 'name'?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Condition Checked' column in the execution_table for step 3

If we remove the condition in setName, what would happen to 'name' after step 2?

A It would stay null

B It would become empty string ""

C It would become "Alice"

D It would cause an error

💡 Hint

Think about what setName does without the condition, referencing step 2 action

Concept Snapshot

Encapsulation means:
- Make fields private
- Use public getters/setters
- Validate data in setters
- Hide internal details
- Control how data changes
This protects data and keeps code safe.

Full Transcript

Encapsulation is a way to keep data safe inside a class by making fields private. We use public methods called getters and setters to read or change the data. The setter method can check if the new value is valid before changing it. For example, in the Person class, the name field is private. The setName method only changes name if the new value is not empty. The getName method returns the current name. This way, outside code cannot directly change name to something invalid. The execution table shows how name starts as null, stays null when setName is called with empty string, and changes to "Alice" when setName is called with a valid name. This protects the data and keeps the class in control of its own state.

Practice

1.

What is the main purpose of encapsulation in Java?

easy

A. To hide the internal data of a class and control access to it

B. To make all variables public so they can be accessed anywhere

C. To allow direct access to class variables without methods

D. To write code faster by skipping method definitions

Solution

1. Step 1: Understand encapsulation concept

   Encapsulation means hiding data inside a class to protect it from outside access.

2. Step 2: Identify the purpose of encapsulation

   It controls how data is accessed or changed using getter and setter methods.

3. Final Answer:

   To hide the internal data of a class and control access to it -> Option A

4. Quick Check:

   Encapsulation = Data hiding and controlled access [OK]

Hint: Encapsulation means hiding data and controlling access [OK]

Common Mistakes:

• Thinking encapsulation means making variables public
• Confusing encapsulation with inheritance
• Believing encapsulation allows direct variable access

2.

Which of the following is the correct way to declare a private variable in a Java class?

class Person {
    ? String name;
}

easy

A. private

B. public

C. protected

D. static

Solution

1. Step 1: Recall Java access modifiers

   Private variables are declared with the keyword private to hide them inside the class.

2. Step 2: Check the options

   Only private hides the variable from outside access, others allow wider access.

3. Final Answer:

   private -> Option A

4. Quick Check:

   Private keyword hides variables [OK]

Hint: Use 'private' to hide variables inside class [OK]

Common Mistakes:

• Using public instead of private for encapsulation
• Confusing protected with private
• Using static which controls memory, not access

3.

What will be the output of the following code?

class Car {
    private String model = "Tesla";
    public String getModel() {
        return model;
    }
}

public class Test {
    public static void main(String[] args) {
        Car car = new Car();
        System.out.println(car.getModel());
    }
}

medium

A. Runtime error

B. Tesla

C. Compilation error

D. null

Solution

1. Step 1: Understand private variable access

   The variable model is private but accessed via the public getter getModel().

2. Step 2: Check the output of getModel()

   The getter returns the string "Tesla", so printing it outputs "Tesla".

3. Final Answer:

   Tesla -> Option B

4. Quick Check:

   Getter returns private variable value [OK]

Hint: Private data accessed via public getter returns value [OK]

Common Mistakes:

• Expecting direct access to private variable
• Thinking code causes compilation error
• Confusing output with null or error

4.

Identify the error in the following code related to encapsulation:

class BankAccount {
    private double balance;
    public void setBalance(double balance) {
        balance = balance;
    }
    public double getBalance() {
        return balance;
    }
}

medium

A. The balance variable should be public

B. The getter method should be private

C. The setter method does not update the class variable correctly

D. The setter method should return a value

Solution

1. Step 1: Analyze the setter method

   The setter uses balance = balance; which assigns the parameter to itself, not the class variable.

2. Step 2: Understand correct assignment

   To update the class variable, use this.balance = balance; to refer to the instance variable.

3. Final Answer:

   The setter method does not update the class variable correctly -> Option C

4. Quick Check:

   Use 'this' to assign parameter to instance variable [OK]

Hint: Use 'this' to assign setter parameter to class variable [OK]

Common Mistakes:

• Forgetting 'this' keyword in setter
• Making getter private which breaks access
• Expecting setter to return a value

5.

You want to create a class Student with a private variable grade that can only be set if the value is between 0 and 100. Which is the best way to implement this using encapsulation?

hard

A. Make grade public and check the value before assigning

B. Make grade static and assign directly

C. Use a protected grade variable and no setter

D. Use a private grade variable with a setter that validates the value

Solution

1. Step 1: Understand encapsulation for validation

   Encapsulation allows controlling how variables are set by using private variables and setters with checks.

2. Step 2: Choose the best practice

   Using a private variable with a setter that validates the input ensures grade stays between 0 and 100.

3. Final Answer:

   Use a private grade variable with a setter that validates the value -> Option D

4. Quick Check:

   Setters with validation keep data safe [OK]

Hint: Validate data inside setter to protect private variables [OK]

Common Mistakes:

• Making variables public and trusting external code
• Skipping validation in setter
• Using static which shares data across all instances