Data hiding in Java - Step-by-Step Execution

Concept Flow - Data hiding

Start

↓

Define class with private variables

↓

Create public methods (getters/setters)

↓

Create object

↓

Access variables only via methods

↓

End

Data hiding means keeping variables private inside a class and accessing them only through public methods.

Execution Sample

Java

class Person {
  private String name;
  public void setName(String n) { name = n; }
  public String getName() { return name; }
}

public class Main {
  public static void main(String[] args) {
    Person p = new Person();
    p.setName("Anna");
    System.out.println(p.getName());
  }
}

This code hides the 'name' variable and accesses it only through setName and getName methods.

Execution Table

Step	Action	Variable/Method	Value/Result	Note
1	Create object	p	Person instance	Object p created
2	Call setter	setName("Anna")	name = "Anna"	Private variable 'name' set to 'Anna'
3	Call getter	getName()	"Anna"	Returns value of 'name'
4	Print output	System.out.println	Anna	Output is 'Anna'
5	Try direct access	p.name	Error	Cannot access private variable directly

💡 Execution stops after printing 'Anna' and error on direct access shows data hiding.

Variable Tracker

Variable	Start	After setName	After getName	Final
name	null	"Anna"	"Anna"	"Anna"

Key Moments - 3 Insights

Why can't we access the variable 'name' directly from the object?

Because 'name' is declared private, it is hidden from outside the class. Only methods inside the class can access it, as shown in step 5 of the execution_table.

How do we change the value of a private variable?

We use a public setter method like setName(), which changes the private variable inside the class, as shown in step 2.

How do we read the value of a private variable?

We use a public getter method like getName(), which returns the value, as shown in step 3.

Visual Quiz - 3 Questions

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

A Error

B null

C "Anna"

D "John"

💡 Hint

Check the 'After setName' column in variable_tracker and step 2 in execution_table.

At which step does the program print the value 'Anna'?

A Step 3

B Step 4

C Step 2

D Step 5

💡 Hint

Look at the 'Print output' action in execution_table.

If the variable 'name' was public, what would happen at step 5?

A Direct access allowed, no error

B Error because variable is private

C Setter method called automatically

D Getter method called automatically

💡 Hint

Step 5 shows error due to private access; if public, direct access would work.

Concept Snapshot

Data hiding means making class variables private.
Access them only via public getter and setter methods.
Prevents outside code from changing variables directly.
Helps protect data and control how it changes.
Use private keyword for variables, public for methods.

Full Transcript

Data hiding in Java means keeping variables private inside a class so that they cannot be accessed directly from outside. Instead, public methods called getters and setters are used to read and change these variables. In the example, the variable 'name' is private. We create a Person object 'p'. We set the name using p.setName("Anna") which changes the private variable inside the class. Then we get the name using p.getName() which returns the value. Trying to access p.name directly causes an error because it is private. This protects the data and controls how it is accessed or changed.

Practice

1. What is the main purpose of data hiding in Java?

easy

A. To keep class variables private and protect them from outside access

B. To make all variables public for easy access

C. To hide methods from the user interface

D. To encrypt data before storing it

Solution

1. Step 1: Understand data hiding concept

   Data hiding means keeping variables private inside a class to prevent direct access from outside.

2. Step 2: Identify the purpose

   This protects data from unwanted changes and bugs by controlling access through methods.

3. Final Answer:

   To keep class variables private and protect them from outside access -> Option A

4. Quick Check:

   Data hiding = keeping variables private [OK]

Hint: Data hiding means making variables private [OK]

Common Mistakes:

• Thinking data hiding means encrypting data
• Confusing data hiding with making variables public
• Believing data hiding hides methods from UI

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

easy

A. int age;

B. public int age;

C. protected int age;

D. private int age;

Solution

1. Step 1: Recall Java access modifiers

   Private variables are declared with the keyword private to restrict access.

2. Step 2: Identify correct syntax

   Only private int age; correctly declares a private variable.

3. Final Answer:

   private int age; -> Option D

4. Quick Check:

   Private variable = private keyword [OK]

Hint: Use 'private' keyword to hide variables [OK]

Common Mistakes:

• Using public or protected instead of private
• Omitting access modifier defaults to package-private
• Confusing private with protected

3. What will be the output of the following Java code?

class Person {
  private String name = "Alice";
  public String getName() {
    return name;
  }
}

public class Test {
  public static void main(String[] args) {
    Person p = new Person();
    System.out.println(p.getName());
  }
}

medium

A. null

B. Compilation error

C. Alice

D. Runtime error

Solution

1. Step 1: Understand private variable access

   The variable name is private but accessed via the public getter getName().

2. Step 2: Trace the output

   The getter returns "Alice", so System.out.println prints "Alice".

3. Final Answer:

   Alice -> Option C

4. Quick Check:

   Getter returns private value = Alice [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 this code related to data hiding:

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

medium

A. The setter method does not update the private variable

B. The getter method should be private

C. The balance variable should be public

D. The class should not have a setter method

Solution

1. Step 1: Analyze setter method

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

2. Step 2: Identify correct assignment

   It should use this.balance = balance; to update the private variable.

3. Final Answer:

   The setter method does not update the private variable -> Option A

4. Quick Check:

   Setter must update class variable using 'this' [OK]

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

Common Mistakes:

• Forgetting 'this' keyword in setter
• Making getter private by mistake
• Changing variable access to public unnecessarily

5. You want to protect a class's sensitive data but allow controlled updates only if the new value is positive. How would you implement this using data hiding in Java?

hard

A. Make the variable public and check the value before assigning it outside the class

B. Make the variable private and write a setter that updates only if the value is positive

C. Make the variable protected and allow direct access in subclasses

D. Use a public variable and no setter method

Solution

1. Step 1: Use private variable for data hiding

   Keep the sensitive variable private to prevent direct external access.

2. Step 2: Implement setter with condition

   Write a setter method that updates the variable only if the new value is positive, ensuring controlled updates.

3. Final Answer:

   Make the variable private and write a setter that updates only if the value is positive -> Option B

4. Quick Check:

   Private variable + conditional setter = safe updates [OK]

Hint: Use private variable with conditional setter method [OK]

Common Mistakes:

• Making variable public and trusting external checks
• Using protected instead of private for sensitive data
• Not validating data in setter method