Encapsulation and information hiding in LLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a private attribute in a class.

LLD

class User:
    def __init__(self, name):
        self.[1]name = name

Drag options to blanks, or click blank then click option'

A__

B_

Cpublic_

Dprivate_

Attempts:

3 left

💡 Hint

Common Mistakes

Using a single underscore only signals 'protected' but does not enforce privacy.

Using 'public_' or 'private_' prefixes are not Python conventions.

In Python, prefixing an attribute with double underscores __ makes it private by name mangling, which helps encapsulate the data.

2fill in blank

medium

Complete the code to provide controlled access to a private attribute using a getter method.

LLD

class Account:
    def __init__(self, balance):
        self.__balance = balance
    def get_[1](self):
        return self.__balance

Drag options to blanks, or click blank then click option'

Aamount

Bbalance

Cvalue

Dmoney

Attempts:

3 left

💡 Hint

Common Mistakes

Naming the getter method differently from the attribute can confuse users.

Trying to access the private attribute directly instead of via getter.

The getter method is conventionally named after the attribute it accesses, here balance.

3fill in blank

hard

Fix the error in the setter method to update the private attribute safely.

LLD

class Employee:
    def __init__(self, salary):
        self.__salary = salary
    def set_salary(self, amount):
        if amount > 0:
            self.[1]salary = amount

Drag options to blanks, or click blank then click option'

Apublic_

B_

Cprivate_

D__

Attempts:

3 left

💡 Hint

Common Mistakes

Using a single underscore or no underscore causes the setter to create a new attribute instead of updating the private one.

Using 'public_' or 'private_' prefixes is incorrect.

The setter must update the private attribute with the double underscore prefix to maintain encapsulation.

4fill in blank

hard

Fill both blanks to implement a property decorator for controlled access to a private attribute.

LLD

class Product:
    def __init__(self, price):
        self.__price = price

    @property
    def [1](self):
        return self.__price

    @[2].setter
    def price(self, value):
        if value >= 0:
            self.__price = value

Drag options to blanks, or click blank then click option'

Aprice

Ccost

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for getter and setter breaks the property.

Forgetting the @property decorator on the getter.

The property and its setter must share the same name to work correctly, here price.

5fill in blank

hard

Fill all three blanks to implement encapsulation with private attribute, getter, and setter using property decorators.

LLD

class BankAccount:
    def __init__(self, balance):
        self.[1]balance = balance

    @property
    def [2](self):
        return self.__balance

    @[3].setter
    def balance(self, amount):
        if amount >= 0:
            self.__balance = amount

Drag options to blanks, or click blank then click option'

A__

Bbalance

D_

Attempts:

3 left

💡 Hint

Common Mistakes

Using single underscore for private attribute weakens encapsulation.

Getter and setter names not matching property name causes errors.

The private attribute uses double underscores __. The property and setter share the name balance for controlled access.

Practice

1. What is the main purpose of encapsulation in system design?

easy

A. To hide internal details and protect data from outside access

B. To make all data publicly accessible for easy modification

C. To increase the size of the system components

D. To allow direct access to all internal variables

Solution

1. Step 1: Understand encapsulation concept

   Encapsulation means hiding the internal details of a system or component so that outside code cannot directly access or change them.

2. Step 2: Identify the main goal

   The main goal is to protect data and control how it is accessed or modified, improving security and reducing errors.

3. Final Answer:

   To hide internal details and protect data from outside access -> Option A

4. Quick Check:

   Encapsulation = Hide details and protect data [OK]

Hint: Encapsulation means hiding details, not exposing them [OK]

Common Mistakes:

• Thinking encapsulation means making data public
• Confusing encapsulation with system size
• Believing encapsulation allows direct variable access

2. Which of the following is the correct way to implement encapsulation in a class?

easy

A. Make all variables public and access them directly

B. Avoid using any methods to access data

C. Use private variables and provide public getter and setter methods

D. Use global variables for all data

Solution

1. Step 1: Recall encapsulation implementation

   Encapsulation is done by making variables private so they cannot be accessed directly from outside the class.

2. Step 2: Use public methods for controlled access

   Public getter and setter methods allow controlled reading and updating of private data.

3. Final Answer:

   Use private variables and provide public getter and setter methods -> Option C

4. Quick Check:

   Private variables + public methods = Encapsulation [OK]

Hint: Private variables + public getters/setters = encapsulation [OK]

Common Mistakes:

• Making variables public defeats encapsulation
• Using global variables breaks encapsulation
• Not providing any access methods causes usability issues

3. Consider this code snippet in a system design context:

class Account {
  private balance = 1000;
  public getBalance() { return this.balance; }
  public setBalance(amount) { if(amount >= 0) this.balance = amount; }
}

const acc = new Account();
acc.setBalance(-500);
console.log(acc.getBalance());

What will be the output?

medium

A. -500

B. 1000

C. 0

D. Error

Solution

1. Step 1: Analyze setBalance method behavior

   The method only updates balance if the amount is greater than or equal to zero.

2. Step 2: Check the call with -500

   Since -500 is less than zero, the balance is not updated and remains 1000.

3. Final Answer:

   1000 -> Option B

4. Quick Check:

   Negative amount ignored, balance stays 1000 [OK]

Hint: Setter blocks negative values, so balance stays unchanged [OK]

Common Mistakes:

• Assuming balance changes to -500
• Expecting zero as default
• Thinking code throws an error

4. A developer wrote this code:

class User {
  public name;
  public setName(newName) { this.name = newName; }
}

const user = new User();
user.name = null;
console.log(user.name);

What is the problem related to encapsulation here?

medium

A. The name variable is public and can be set to invalid values directly

B. The setName method is missing

C. The class should not have any variables

D. The console.log statement is incorrect

Solution

1. Step 1: Identify variable access level

   The variable name is public, so it can be changed directly without validation.

2. Step 2: Understand encapsulation violation

   Direct access allows setting invalid values like null, bypassing any checks in setName.

3. Final Answer:

   The name variable is public and can be set to invalid values directly -> Option A

4. Quick Check:

   Public variable allows invalid direct access [OK]

Hint: Public variables can be changed without checks, breaking encapsulation [OK]

Common Mistakes:

• Thinking setName method is missing
• Believing variables should be removed
• Blaming console.log for output

5. You are designing a banking system where account balance must never be negative. Which approach best uses encapsulation and information hiding to enforce this rule?

hard

A. Make balance public and rely on users to not set negative values

B. Store balance as a global variable accessible everywhere

C. Do not provide any methods to access balance

D. Make balance private and provide a setter that only updates if amount ≥ 0

Solution

1. Step 1: Protect balance data

   Making balance private hides it from direct external changes, preventing accidental or malicious updates.

2. Step 2: Control updates via setter method

   The setter method enforces the rule by allowing updates only if the new amount is zero or positive.

3. Step 3: Avoid unsafe alternatives

   Public or global variables allow uncontrolled changes, risking negative balances and errors.

4. Final Answer:

   Make balance private and provide a setter that only updates if amount ≥ 0 -> Option D

5. Quick Check:

   Private balance + validated setter = safe encapsulation [OK]

Hint: Private data + validated setter enforces rules safely [OK]

Common Mistakes:

• Making balance public and trusting users
• Not providing access methods causes usability issues
• Using global variables breaks encapsulation