Encapsulation

Encapsulation is one of the fundamental principles of Object-Oriented Programming. It involves bundling data (attributes) and methods that operate on that data within a single unit (class), while restricting direct access to some components to prevent accidental modification.

Understanding Access Modifiers

Access modifiers control the visibility and accessibility of class members (attributes and methods).

Access Levels Comparison

Python

access_levels.py

class User:
    def __init__(self, username: str, email: str, password: str):
        self.username = username      # Public attribute
        self._email = email           # Protected attribute (convention)
        self.__password = password    # Private attribute (name mangling)

    def public_method(self):
        """Public method - accessible from anywhere"""
        return "Public method"

    def _protected_method(self):
        """Protected method - intended for internal use"""
        return "Protected method"

    def __private_method(self):
        """Private method - name-mangled, harder to access"""
        return "Private method"

Key Differences

Access Level	Syntax	Enforcement	Use Case
Public	attribute	None	Accessible from anywhere
Protected	_attribute	Convention only	Internal use, accessible but discouraged
Private	__attribute	Name mangling	Truly internal, harder to access accidentally

Java

AccessLevels.java

public class User {
    public String username;        // Public attribute
    protected String email;        // Protected attribute
    private String password;       // Private attribute

    public User(String username, String email, String password) {
        this.username = username;
        this.email = email;
        this.password = password;
    }

    // Public method - accessible from anywhere
    public String publicMethod() {
        return "Public method";
    }

    // Protected method - accessible within package and subclasses
    protected String protectedMethod() {
        return "Protected method";
    }

    // Private method - only accessible within this class
    private String privateMethod() {
        return "Private method";
    }
}

Key Differences

Access Level	Syntax	Enforcement	Use Case
Public	public	Enforced	Accessible from anywhere
Protected	protected	Enforced	Accessible within package and subclasses
Private	private	Enforced	Only accessible within the class
Package	(default)	Enforced	Accessible within the same package

Protected Attributes/Members

Protected members are intended for internal use but can be accessed by subclasses.

Python

protected_example.py

class User:
    def __init__(self, username: str, password: str):
        self.username = username
        self._password = password  # Protected attribute

    def get_password(self):
        return self._password

    def set_password(self, new_password: str):
        self._password = new_password

user = User("john_doe", "secret123")
print(user._password)  # Works, but not recommended
print(user.get_password())  # Preferred way

Important

• Python doesn’t enforce this - it’s a convention only
• Signals “internal use, don’t touch”
• Still accessible, but developers should respect the convention

Remember: Protected attributes are still accessible from outside the class. Python trusts developers to follow conventions!

Java

ProtectedExample.java

public class User {
    protected String password;  // Protected attribute

    public User(String username, String password) {
        this.password = password;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String newPassword) {
        this.password = newPassword;
    }
}

// In same package or subclass
public class AdminUser extends User {
    public AdminUser(String username, String password) {
        super(username, password);
    }

    public void resetPassword() {
        // Can access protected member
        this.password = "new_password";
    }
}

Java Protected

• Protected members are accessible within the same package and by subclasses
• More restrictive than Python’s convention-based approach
• Enforced by the compiler

Private Attributes/Members

Private members are truly internal and should not be accessed from outside the class.

Python

private_example.py

class User:
    def __init__(self, username: str, password: str):
        self.username = username
        self.__password = password  # Private attribute (name-mangled)

    def get_password(self):
        return self.__password  # Accessible within class

user = User("john_doe", "secret123")
# print(user.__password)  # AttributeError: 'User' object has no attribute '__password'
print(user.get_password())  # Works: "secret123"
# print(user._User__password)  # Works but DON'T DO THIS: "secret123"

Name Mangling

• Triggers name mangling - Python changes the name internally
• Becomes _ClassName__attribute internally
• Still accessible, but harder to access by accident
• Prevents accidental overriding in subclasses

Note: While you can still access _ClassName__attribute, it’s strongly discouraged. Use this for truly internal implementation details.

Java

PrivateExample.java

public class User {
    private String password;  // Private attribute

    public User(String username, String password) {
        this.password = password;
    }

    public String getPassword() {
        return password;  // Accessible within class
    }

    // Private method
    private String hashPassword(String password) {
        // Internal implementation
        return "hashed_" + password;
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        User user = new User("john_doe", "secret123");
        // System.out.println(user.password);  // Compile error: password has private access
        System.out.println(user.getPassword());  // Works: "secret123"
    }
}

Java Private

• Private members are only accessible within the same class
• Enforced by the compiler - cannot be accessed from outside
• Use getters/setters to control access

Properties: The Pythonic Way

In Python, you usually don’t write getters/setters unless you need validation or transformation. Properties provide a clean way to add getters/setters.

Python

properties_example.py

class User:
    def __init__(self, username: str, email: str, password: str):
        self.username = username
        self.email = email
        self._password = password  # Protected attribute

    @property
    def password(self):
        """Getter - accessed like an attribute"""
        return self._password

    @password.setter
    def password(self, new_password: str):
        """Setter - accessed like attribute assignment"""
        if len(new_password) < 8:
            raise ValueError("Password must be at least 8 characters")
        self._password = new_password

user = User("john", "john@example.com", "old_password")
user.password = "new_password"  # Clean syntax, uses setter
print(user.password)  # Clean syntax, uses getter
# user.password = "short"  # Raises ValueError

Java

PropertiesExample.java

public class User {
    private String password;

    public User(String username, String email, String password) {
        this.password = password;
    }

    // Getter
    public String getPassword() {
        return password;
    }

    // Setter with validation
    public void setPassword(String newPassword) {
        if (newPassword.length() < 8) {
            throw new IllegalArgumentException("Password must be at least 8 characters");
        }
        this.password = newPassword;
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        User user = new User("john", "john@example.com", "old_password");
        user.setPassword("new_password");  // Uses setter
        System.out.println(user.getPassword());  // Uses getter
        // user.setPassword("short");  // Throws IllegalArgumentException
    }
}

Encapsulation in Practice

Bad Example: No Encapsulation

Python

bad_encapsulation.py

class BankAccount:
    def __init__(self, initial_balance: float):
        self.balance = initial_balance  # Public attribute - dangerous!

    def deposit(self, amount: float):
        self.balance += amount

    def withdraw(self, amount: float):
        self.balance -= amount

account = BankAccount(1000.0)
account.balance = -500.0  # Direct modification - unsafe!
print(account.balance)  # -500.0 (incorrect in banking!)

Java

BadEncapsulation.java

public class BankAccount {
    public double balance;  // Public attribute - dangerous!

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

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

    public void withdraw(double amount) {
        balance -= amount;
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount(1000.0);
        account.balance = -500.0;  // Direct modification - unsafe!
        System.out.println(account.balance);  // -500.0 (incorrect in banking!)
    }
}

Good Example: Proper Encapsulation

Python

good_encapsulation.py

class BankAccount:
    def __init__(self, initial_balance: float):
        self.__balance = initial_balance  # Private attribute

    def deposit(self, amount: float):
        """Deposit money with validation"""
        if amount > 0:
            self.__balance += amount
        else:
            raise ValueError("Deposit amount must be positive")

    def withdraw(self, amount: float):
        """Withdraw money with validation"""
        if amount <= 0:
            raise ValueError("Withdrawal amount must be positive")
        if amount > self.__balance:
            raise ValueError("Insufficient funds")
        self.__balance -= amount

    @property
    def balance(self):
        """Read-only access to balance"""
        return self.__balance

account = BankAccount(1000.0)
account.deposit(500.0)
account.withdraw(200.0)
print(account.balance)  # 1300.0

# account.__balance = -500.0  # Won't affect actual balance (name mangling)
# account.balance = -500.0  # AttributeError: can't set attribute

Java

GoodEncapsulation.java

public class BankAccount {
    private double balance;  // Private attribute

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

    // Deposit money with validation
    public void deposit(double amount) {
        if (amount > 0) {
            this.balance += amount;
        } else {
            throw new IllegalArgumentException("Deposit amount must be positive");
        }
    }

    // Withdraw money with validation
    public void withdraw(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Withdrawal amount must be positive");
        }
        if (amount > this.balance) {
            throw new IllegalArgumentException("Insufficient funds");
        }
        this.balance -= amount;
    }

    // Read-only access to balance
    public double getBalance() {
        return balance;
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount(1000.0);
        account.deposit(500.0);
        account.withdraw(200.0);
        System.out.println(account.getBalance());  // 1300.0

        // account.balance = -500.0;  // Compile error: balance has private access
    }
}

Visual Representation

Key Takeaways

Remember

• Encapsulation bundles data and methods together while controlling access
• Python: Uses naming conventions (_ protected, __ private) - not enforced
• Java: Uses keywords (public, protected, private) - enforced by compiler
• Protected attributes (_attr in Python, protected in Java) are for internal use
• Private attributes (__attr in Python, private in Java) are truly internal
• Properties (Python) and getters/setters (Java) provide controlled access
• Use encapsulation to create clear interfaces and prevent accidental misuse

Remember: In Python, encapsulation is more about convention and design than strict enforcement. In Java, encapsulation is enforced by the compiler. The goal is to create clear interfaces and prevent accidental misuse.