Classes/objects and encapsulation - Computer Science A AP Study Notes

Object-Oriented Programming (OOP) is a programming paradigm that organizes code around objects rather than functions and logic. A class is a blueprint or template that defines the structure and behavior of objects, containing attributes (data fields/properties) and methods (functions that operate on those attributes). An object is a specific instance of a class with actual values assigned to its attributes.

Encapsulation is a fundamental OOP principle that bundles data and methods operating on that data within a single unit (the class), while restricting direct access to internal components. This is achieved through access modifiers: public (accessible everywhere), private (accessible only within the class), and protected (accessible within the class and subclasses).

Key terminology:

• Constructor: A special method automatically called when creating an object, typically initializing attributes
• Instance variables: Attributes unique to each object instance
• Class variables: Attributes shared across all instances of a class
• Getter methods: Public methods that return private attribute values
• Setter methods: Public methods that modify private attributes with validation

Cambridge Definition: Encapsulation ensures data hiding and abstraction, protecting object integrity by preventing unauthorized external access and modification.

The principle follows information hiding: internal implementation details remain hidden while providing a well-defined interface. This enhances code maintainability, reduces coupling between components, and prevents accidental data corruption. Encapsulation supports the Don't Repeat Yourself (DRY) principle and facilitates easier debugging and testing.

Think of a class as a cookie cutter and objects as the actual cookies. The cookie cutter defines the shape (structure), while each cookie is a unique instance with its own characteristics (chocolate chips, size variations).

Real-world banking example: A BankAccount class encapsulates account data. You cannot directly access someone's balance—you must use methods like deposit() or withdraw(). This mirrors real banking where tellers (methods) process transactions rather than customers directly manipulating vault contents (private data).

class BankAccount {
    private double balance;  // Encapsulated - cannot access directly
    private String accountNumber;
    
    public void deposit(double amount) {
        if (amount > 0) balance += amount;
    }
    
    public double getBalance() {
        return balance;  // Controlled access
    }
}

Car analogy: When driving, you use the steering wheel, pedals, and gear stick (public interface) without knowing engine mechanics (private implementation). The car encapsulates complex systems—you can't accidentally damage the engine because direct access is prevented.

Medical records system: Patient data (diagnosis, medications) must be private for confidentiality. Only authorized methods (doctor login, prescription updates) can access information, demonstrating encapsulation's security benefits.

Benefits in practice:

• Validation: Setters can reject invalid data (negative ages, empty names)
• Flexibility: Internal implementation changes don't affect external code using the class
• Security: Sensitive data remains protected from unauthorized modification
• Debugging: Errors traced to specific methods rather than scattered code

Encapsulation creates modular, maintainable systems where components interact through well-defined interfaces, essential in large-scale software development.