OOP Encapsulation

Master encapsulation and information hiding to create robust, maintainable object-oriented systems. This skill focuses on controlling access to object internals and exposing well-defined interfaces.

Understanding Encapsulation

Encapsulation is the bundling of data and methods that operate on that data within a single unit, while restricting direct access to some of the object's components. This principle protects object integrity and reduces coupling.

Java Encapsulation

// Strong encapsulation with validation public class BankAccount { private String accountNumber; private BigDecimal balance; private final List<Transaction> transactions;

public BankAccount(String accountNumber, BigDecimal initialBalance) {
    if (accountNumber == null || accountNumber.isEmpty()) {
        throw new IllegalArgumentException("Account number required");
    }
    if (initialBalance.compareTo(BigDecimal.ZERO) < 0) {
        throw new IllegalArgumentException("Initial balance cannot be negative");
    }

    this.accountNumber = accountNumber;
    this.balance = initialBalance;
    this.transactions = new ArrayList<>();
}

// Read-only access to account number
public String getAccountNumber() {
    return accountNumber;
}

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

// Defensive copy for collection
public List<Transaction> getTransactions() {
    return Collections.unmodifiableList(transactions);
}

// Controlled mutation with validation
public void deposit(BigDecimal amount) {
    if (amount.compareTo(BigDecimal.ZERO) <= 0) {
        throw new IllegalArgumentException("Deposit amount must be positive");
    }

    balance = balance.add(amount);
    transactions.add(new Transaction(TransactionType.DEPOSIT, amount));
}

// Controlled mutation with business logic
public void withdraw(BigDecimal amount) {
    if (amount.compareTo(BigDecimal.ZERO) <= 0) {
        throw new IllegalArgumentException("Withdrawal amount must be positive");
    }
    if (amount.compareTo(balance) > 0) {
        throw new InsufficientFundsException("Insufficient balance");
    }

    balance = balance.subtract(amount);
    transactions.add(new Transaction(TransactionType.WITHDRAWAL, amount));
}

}

Python Encapsulation

class Employee: """Employee with encapsulated salary information."""

def __init__(self, name: str, salary: float, department: str):
    if not name:
        raise ValueError("Name is required")
    if salary < 0:
        raise ValueError("Salary cannot be negative")

    self._name = name  # Protected attribute
    self.__salary = salary  # Private attribute (name mangling)
    self._department = department
    self.__performance_rating = 0.0

@property
def name(self) -> str:
    """Read-only access to name."""
    return self._name

@property
def department(self) -> str:
    """Read-only access to department."""
    return self._department

@property
def salary(self) -> float:
    """Controlled access to salary."""
    return self.__salary

@salary.setter
def salary(self, value: float) -> None:
    """Controlled mutation with validation."""
    if value < 0:
        raise ValueError("Salary cannot be negative")
    if value < self.__salary * 0.9:
        raise ValueError("Salary cannot decrease by more than 10%")

    self.__salary = value

@property
def performance_rating(self) -> float:
    """Read-only access to performance rating."""
    return self.__performance_rating

def update_performance(self, rating: float) -> None:
    """Controlled update with validation and side effects."""
    if not 0 <= rating <= 5:
        raise ValueError("Rating must be between 0 and 5")

    self.__performance_rating = rating

    # Business logic: automatic raise for high performers
    if rating >= 4.5:
        self.__salary *= 1.10

def give_raise(self, percentage: float) -> None:
    """Apply percentage raise with validation."""
    if percentage < 0:
        raise ValueError("Raise percentage cannot be negative")
    if percentage > 20:
        raise ValueError("Single raise cannot exceed 20%")

    self.__salary *= (1 + percentage / 100)

def __repr__(self) -> str:
    return f"Employee(name={self._name}, department={self._department})"

TypeScript Encapsulation

// Class-based encapsulation with private fields class UserAccount { readonly #id: string; #username: string; #email: string; #passwordHash: string; #lastLoginAt: Date | null = null; #failedLoginAttempts = 0; #isLocked = false;

constructor(username: string, email: string, passwordHash: string) { if (!username || username.length < 3) { throw new Error("Username must be at least 3 characters"); } if (!this.isValidEmail(email)) { throw new Error("Invalid email format"); }

this.#id = crypto.randomUUID();
this.#username = username;
this.#email = email;
this.#passwordHash = passwordHash;

}

// Read-only access get id(): string { return this.#id; }

get username(): string { return this.#username; }

get email(): string { return this.#email; }

get lastLoginAt(): Date | null { return this.#lastLoginAt; }

get isLocked(): boolean { return this.#isLocked; }

// Controlled mutation with validation updateEmail(newEmail: string): void { if (!this.isValidEmail(newEmail)) { throw new Error("Invalid email format"); } this.#email = newEmail; }

// Business logic encapsulated attemptLogin(password: string): boolean { if (this.#isLocked) { throw new Error("Account is locked"); }

if (this.verifyPassword(password)) {
  this.#lastLoginAt = new Date();
  this.#failedLoginAttempts = 0;
  return true;
}

this.#failedLoginAttempts++;
if (this.#failedLoginAttempts >= 3) {
  this.#isLocked = true;
}
return false;

}

// Private helper methods private isValidEmail(email: string): boolean { return /^[^\s@]+@[^\s@]+.[^\s@]+$/.test(email); }

private verifyPassword(password: string): boolean { // Hash comparison logic return true; // Simplified }

unlock(): void { this.#isLocked = false; this.#failedLoginAttempts = 0; } }

C# Encapsulation

// Strong encapsulation with properties and backing fields public class Product { private readonly Guid _id; private string _name; private decimal _price; private int _stockQuantity; private readonly List<PriceHistory> _priceHistory;

public Product(string name, decimal price, int initialStock)
{
    if (string.IsNullOrWhiteSpace(name))
        throw new ArgumentException("Product name is required", nameof(name));

    if (price <= 0)
        throw new ArgumentException("Price must be positive", nameof(price));

    if (initialStock < 0)
        throw new ArgumentException("Stock cannot be negative", nameof(initialStock));

    _id = Guid.NewGuid();
    _name = name;
    _price = price;
    _stockQuantity = initialStock;
    _priceHistory = new List<PriceHistory>
    {
        new PriceHistory(price, DateTime.UtcNow)
    };
}

// Read-only property
public Guid Id => _id;

// Property with validation
public string Name
{
    get => _name;
    set
    {
        if (string.IsNullOrWhiteSpace(value))
            throw new ArgumentException("Product name is required");
        _name = value;
    }
}

// Property with side effects
public decimal Price
{
    get => _price;
    set
    {
        if (value <= 0)
            throw new ArgumentException("Price must be positive");

        if (value != _price)
        {
            _price = value;
            _priceHistory.Add(new PriceHistory(value, DateTime.UtcNow));
        }
    }
}

public int StockQuantity => _stockQuantity;

// Defensive copy for collection
public IReadOnlyList<PriceHistory> PriceHistory => _priceHistory.AsReadOnly();

// Encapsulated business logic
public bool TryReserveStock(int quantity)
{
    if (quantity <= 0)
        throw new ArgumentException("Quantity must be positive");

    if (_stockQuantity >= quantity)
    {
        _stockQuantity -= quantity;
        return true;
    }

    return false;
}

public void RestockItems(int quantity)
{
    if (quantity <= 0)
        throw new ArgumentException("Quantity must be positive");

    _stockQuantity += quantity;
}

public decimal GetAveragePrice()
{
    return _priceHistory.Average(h => h.Price);
}

}

public record PriceHistory(decimal Price, DateTime ChangedAt);

Data Hiding Patterns

Information Hiding in Java

// Module pattern with package-private implementation public class OrderProcessor { private final OrderValidator validator; private final InventoryService inventory; private final PaymentGateway payment;

public OrderProcessor(
    OrderValidator validator,
    InventoryService inventory,
    PaymentGateway payment
) {
    this.validator = validator;
    this.inventory = inventory;
    this.payment = payment;
}

// Public interface - what clients need to know
public OrderResult processOrder(Order order) {
    try {
        validateOrder(order);
        reserveInventory(order);
        processPayment(order);
        return OrderResult.success(order.getId());
    } catch (ValidationException e) {
        return OrderResult.validationError(e.getMessage());
    } catch (InventoryException e) {
        return OrderResult.inventoryError(e.getMessage());
    } catch (PaymentException e) {
        releaseInventory(order);
        return OrderResult.paymentError(e.getMessage());
    }
}

// Private implementation - hidden from clients
private void validateOrder(Order order) {
    if (!validator.isValid(order)) {
        throw new ValidationException("Order validation failed");
    }
}

private void reserveInventory(Order order) {
    for (OrderItem item : order.getItems()) {
        if (!inventory.reserve(item.getProductId(), item.getQuantity())) {
            throw new InventoryException("Insufficient inventory");
        }
    }
}

private void processPayment(Order order) {
    PaymentRequest request = createPaymentRequest(order);
    PaymentResponse response = payment.charge(request);

    if (!response.isSuccessful()) {
        throw new PaymentException("Payment processing failed");
    }
}

private void releaseInventory(Order order) {
    for (OrderItem item : order.getItems()) {
        inventory.release(item.getProductId(), item.getQuantity());
    }
}

private PaymentRequest createPaymentRequest(Order order) {
    return PaymentRequest.builder()
        .orderId(order.getId())
        .amount(order.getTotalAmount())
        .customerId(order.getCustomerId())
        .build();
}

}

Closure-Based Encapsulation in TypeScript

// Factory function with closures for private state function createCounter(initialValue = 0) { // Private state - not accessible outside let count = initialValue; const listeners: Array<(value: number) => void> = [];

// Private functions function notifyListeners(): void { listeners.forEach(listener => listener(count)); }

// Public interface return { // Read-only access getValue(): number { return count; },

// Controlled mutation
increment(): void {
  count++;
  notifyListeners();
},

decrement(): void {
  count--;
  notifyListeners();
},

reset(): void {
  count = initialValue;
  notifyListeners();
},

// Observer pattern
subscribe(listener: (value: number) => void): () => void {
  listeners.push(listener);
  // Return unsubscribe function
  return () => {
    const index = listeners.indexOf(listener);
    if (index > -1) {
      listeners.splice(index, 1);
    }
  };
}

}; }

// Usage const counter = createCounter(10); const unsubscribe = counter.subscribe(value => console.log(Count: ${value})); counter.increment(); // Logs: Count: 11 counter.increment(); // Logs: Count: 12 unsubscribe(); counter.increment(); // No log

Module Pattern in Python

Module with private implementation details

from typing import Dict, List, Optional from dataclasses import dataclass from datetime import datetime

@dataclass class CacheEntry: """Internal representation - not exported.""" value: any expires_at: datetime access_count: int = 0

class Cache: """Public cache interface."""

def __init__(self, max_size: int = 100):
    self.__entries: Dict[str, CacheEntry] = {}
    self.__max_size = max_size
    self.__hits = 0
    self.__misses = 0

def get(self, key: str) -> Optional[any]:
    """Get value from cache."""
    entry = self.__entries.get(key)

    if entry is None:
        self.__misses += 1
        return None

    if self.__is_expired(entry):
        self.__remove(key)
        self.__misses += 1
        return None

    self.__hits += 1
    entry.access_count += 1
    return entry.value

def set(self, key: str, value: any, ttl_seconds: int = 3600) -> None:
    """Set value in cache with TTL."""
    if len(self.__entries) >= self.__max_size:
        self.__evict_least_used()

    expires_at = datetime.now() + timedelta(seconds=ttl_seconds)
    self.__entries[key] = CacheEntry(value, expires_at)

def delete(self, key: str) -> bool:
    """Remove entry from cache."""
    return self.__remove(key)

def clear(self) -> None:
    """Clear all cache entries."""
    self.__entries.clear()
    self.__hits = 0
    self.__misses = 0

def get_stats(self) -> Dict[str, int]:
    """Get cache statistics."""
    return {
        'size': len(self.__entries),
        'hits': self.__hits,
        'misses': self.__misses,
        'hit_rate': self.__calculate_hit_rate()
    }

# Private methods - implementation details
def __is_expired(self, entry: CacheEntry) -> bool:
    return datetime.now() > entry.expires_at

def __remove(self, key: str) -> bool:
    if key in self.__entries:
        del self.__entries[key]
        return True
    return False

def __evict_least_used(self) -> None:
    if not self.__entries:
        return

    least_used = min(
        self.__entries.items(),
        key=lambda item: item[1].access_count
    )
    self.__remove(least_used[0])

def __calculate_hit_rate(self) -> float:
    total = self.__hits + self.__misses
    return self.__hits / total if total > 0 else 0.0

Access Control Levels

Java Access Modifiers

// Demonstrating all access levels public class AccessControlExample {

// Private - only within this class
private String secretKey;

// Package-private (default) - within same package
String packageData;

// Protected - within package and subclasses
protected String inheritableData;

// Public - everywhere
public String publicData;

// Private constructor for factory pattern
private AccessControlExample(String key) {
    this.secretKey = key;
}

// Public factory method
public static AccessControlExample create(String key) {
    return new AccessControlExample(key);
}

// Private helper method
private boolean validateKey(String key) {
    return key != null && key.length() >= 10;
}

// Protected method for subclasses
protected void performSecureOperation() {
    if (validateKey(secretKey)) {
        // Operation logic
    }
}

// Public interface method
public String getPublicInfo() {
    return "Public information";
}

}

// Nested class for internal implementation class InternalHelper { // Package-private - only used within package static void helperMethod() { // Implementation } }

C# Access Levels

// Comprehensive access control public class PaymentProcessor { // Private field - only within class private readonly IPaymentGateway _gateway;

// Protected field - class and derived classes
protected readonly ILogger _logger;

// Internal - within same assembly
internal readonly string AssemblyId;

// Protected internal - within assembly OR derived classes
protected internal readonly DateTime CreatedAt;

// Private protected - within class AND derived classes in same assembly
private protected readonly string ProcessorId;

// Public constructor
public PaymentProcessor(IPaymentGateway gateway, ILogger logger)
{
    _gateway = gateway ?? throw new ArgumentNullException(nameof(gateway));
    _logger = logger ?? throw new ArgumentNullException(nameof(logger));
    AssemblyId = Guid.NewGuid().ToString();
    CreatedAt = DateTime.UtcNow;
    ProcessorId = GenerateProcessorId();
}

// Public method - external interface
public async Task<PaymentResult> ProcessPaymentAsync(PaymentRequest request)
{
    ValidateRequest(request);
    return await ExecutePaymentAsync(request);
}

// Protected method - for derived classes
protected virtual void ValidateRequest(PaymentRequest request)
{
    if (request == null)
        throw new ArgumentNullException(nameof(request));

    if (request.Amount <= 0)
        throw new ArgumentException("Amount must be positive");
}

// Private method - internal implementation
private async Task<PaymentResult> ExecutePaymentAsync(PaymentRequest request)
{
    _logger.LogInformation($"Processing payment: {request.Id}");

    try
    {
        var response = await _gateway.ChargeAsync(request);
        return ConvertToResult(response);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Payment processing failed");
        return PaymentResult.Failed(ex.Message);
    }
}

// Internal method - used by assembly
internal void ResetGateway()
{
    // Reset logic
}

// Private helper
private static string GenerateProcessorId()
{
    return $"PROC-{Guid.NewGuid():N}";
}

// Private conversion
private PaymentResult ConvertToResult(GatewayResponse response)
{
    return response.Success
        ? PaymentResult.Succeeded(response.TransactionId)
        : PaymentResult.Failed(response.ErrorMessage);
}

}

Immutability and Encapsulation

Immutable Objects in Java

// Immutable class - encapsulation through immutability public final class Money { private final BigDecimal amount; private final Currency currency;

private Money(BigDecimal amount, Currency currency) {
    this.amount = amount;
    this.currency = currency;
}

public static Money of(BigDecimal amount, Currency currency) {
    Objects.requireNonNull(amount, "Amount required");
    Objects.requireNonNull(currency, "Currency required");
    return new Money(amount, currency);
}

public static Money zero(Currency currency) {
    return new Money(BigDecimal.ZERO, currency);
}

// All getters return copies or immutable values
public BigDecimal getAmount() {
    return amount;
}

public Currency getCurrency() {
    return currency;
}

// Operations return new instances
public Money add(Money other) {
    if (!currency.equals(other.currency)) {
        throw new IllegalArgumentException("Currency mismatch");
    }
    return new Money(amount.add(other.amount), currency);
}

public Money subtract(Money other) {
    if (!currency.equals(other.currency)) {
        throw new IllegalArgumentException("Currency mismatch");
    }
    return new Money(amount.subtract(other.amount), currency);
}

public Money multiply(BigDecimal factor) {
    return new Money(amount.multiply(factor), currency);
}

@Override
public boolean equals(Object obj) {
    if (this == obj) return true;
    if (!(obj instanceof Money)) return false;
    Money other = (Money) obj;
    return amount.equals(other.amount) && currency.equals(other.currency);
}

@Override
public int hashCode() {
    return Objects.hash(amount, currency);
}

@Override
public String toString() {
    return String.format("%s %s", currency.getSymbol(), amount);
}

}

When to Use This Skill

Apply encapsulation principles when:

• Designing classes and modules with internal state

• Creating domain objects with business rules

• Building APIs and public interfaces

• Protecting object invariants

• Hiding implementation details

• Preventing invalid state transitions

• Managing complex internal structures

• Implementing data validation

• Creating defensive copies of mutable objects

• Controlling access to sensitive data

• Implementing access control policies

• Building frameworks and libraries

• Refactoring procedural code to OOP

• Designing immutable value objects

• Creating thread-safe classes

Best Practices

• Make fields private by default, expose through methods

• Use the principle of least privilege for access levels

• Validate all inputs in public methods

• Return defensive copies of mutable internal objects

• Make classes immutable when possible

• Use final/readonly for fields that don't change

• Encapsulate collections, never expose them directly

• Keep implementation details private

• Use properties/getters for controlled access

• Implement validation in setters/mutators

• Group related data and behavior together

• Hide complexity behind simple interfaces

• Use package-private/internal for implementation classes

• Avoid getter/setter pairs for every field

• Design for change by hiding what might vary

Common Pitfalls

• Creating getter/setter for every field (JavaBeans antipattern)

• Exposing mutable internal collections directly

• Making fields public "for convenience"

• Returning references to mutable internal objects

• Using protected fields instead of protected methods

• Overusing inheritance to access protected members

• Ignoring validation in constructors

• Allowing objects to be created in invalid states

• Mixing business logic in getters/setters

• Using static mutable state

• Forgetting to make defensive copies

• Exposing implementation details through exceptions

• Not considering thread safety for mutable state

• Breaking encapsulation with friend classes

• Using reflection to access private members

Resources

• Effective Java by Joshua Bloch (Encapsulation chapters)

• Clean Code by Robert Martin (Objects and Data Structures)

• Design Patterns: Elements of Reusable Object-Oriented Software

• Python Data Model: https://docs.python.org/3/reference/datamodel.html

• C# Properties: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/properties

• Java Access Control: https://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html

• TypeScript Private Fields: https://www.typescriptlang.org/docs/handbook/2/classes.html#private