OOP Encapsulation

On Part 1 every attribute was public — any code could read or change it directly. That is risky: nothing stops a careless line from setting a bank balance to a negative number. Real programs protect their data.

The fix is encapsulation: make the attributes private so outside code cannot touch them directly, then provide getter and setter methods as the only doorway in and out. The setter can check a value before storing it. By the end of this page you will hide data, read it with getters, update it with setters, and reject invalid values.

In Python you make an attribute private by putting two underscores in front of its name: self.__balance. Code outside the class then cannot read or change __balance directly — it must go through a method. In Cambridge pseudocode you write the keyword PRIVATE in front of the declaration.

class BankAccount:
    def __init__(self, holder, balance):
        self.__holder  = holder    # private attribute
        self.__balance = balance   # private attribute

The pseudocode equivalent uses the keyword PRIVATE:

CLASS BankAccount
    PRIVATE Holder : STRING
    PRIVATE Balance : REAL
    PUBLIC PROCEDURE NEW(GivenHolder : STRING, GivenBalance : REAL)
        Holder  <- GivenHolder
        Balance <- GivenBalance
    ENDPROCEDURE
ENDCLASS

A getter is a method that simply returns the private attribute. A setter takes a new value as a parameter and assigns it. Both reach the private attribute through self. from inside the class — which is allowed, because private only blocks access from outside.

class Person:
    def __init__(self, name, age):
        self.__name = name   # private
        self.__age  = age    # private

    def get_name(self):            # getter
        return self.__name

    def set_name(self, new_name):  # setter
        self.__name = new_name

# usage
person = Person("Mehrin", 16)
print(person.get_name())   # Mehrin
person.set_name("Nazifa")
print(person.get_name())   # Nazifa

Add an if inside the setter. If the value is valid, store it; otherwise leave the attribute unchanged and report the problem. The same idea powers deposit and withdraw methods, which validate before changing the balance.

class BankAccount:
    def __init__(self, balance=0):
        self.__balance = balance      # private

    def get_balance(self):
        return self.__balance

    def set_balance(self, amount):
        if amount >= 0:                     # validate first
            self.__balance = amount         # store second
        else:
            print("Balance cannot be negative.")

    def withdraw(self, amount):
        if amount <= self.__balance:
            self.__balance = self.__balance - amount
        else:
            print("Invalid withdrawal amount.")

Fifteen exam-style tasks. Click Hint for bullet-point guidance, then Help to reveal a worked Python solution.