Wat is Objectgeoriënteerd Programmeren (OOP) in Python?

Aan het einde van dit hoofdstuk snap je:

• wat OOP is (in gewone mensentaal),
• waarom je het zou gebruiken in Python,
• de kernbegrippen (encapsulation, inheritance, polymorphism, abstraction) in een Python-interpretatie,
• het verschil tussen class, object en instance,
• en je ziet één mini-voorbeeld + een “real-world” analogie (auto).

Wat is OOP eigenlijk? #

Objectgeoriënteerd programmeren is een manier van programmeren waarbij je je programma opdeelt in objecten die:

• state hebben (data/attributen), en
• gedrag hebben (methodes/functies die bij die data horen).

In plaats van “een hoop losse functies die overal data manipuleren”, bundel je data + logica bij elkaar in één concept: een object.

Procedureel (simpel, direct) #

Je schrijft vooral functies die data (bijv. dicts, lists) ontvangen en teruggeven.

Wanneer fijn:

• scripts, kleine tools, data-transformaties
• “één keer runnen” code
• als je flow vooral lineair is (stap 1 → 2 → 3)

Voorbeeld (procedureel):

def apply_discount(price, pct):
    return price * (1 - pct)

cart_total = 100
cart_total = apply_discount(cart_total, 0.10)
print(cart_total)

def apply_discount(price, pct):
    return price * (1 - pct)

cart_total = 100
cart_total = apply_discount(cart_total, 0.10)
print(cart_total)

OOP (structuur, groei, onderhoud) #

Je modelleert je domein als objecten (bijv. Cart, Product, Order) met methodes die het gedrag bewaken.

Wanneer fijn:

• grotere projecten of codebases die blijven groeien
• wanneer je “dingen” hebt met duidelijke regels/gedrag (users, orders, voertuigen, accounts)
• wanneer je state moet bewaken en consistent houden
• wanneer je uitbreidbaarheid wil (meerdere varianten, plugins, strategieën)

Voorbeeld (OOP):

class Cart:
    def __init__(self):
        self.total = 0

    def apply_discount(self, pct):
        self.total *= (1 - pct)

cart = Cart()
cart.total = 100
cart.apply_discount(0.10)
print(cart.total)

class Cart:
    def __init__(self):
        self.total = 0

    def apply_discount(self, pct):
        self.total *= (1 - pct)

cart = Cart()
cart.total = 100
cart.apply_discount(0.10)
print(cart.total)

Belangrijk: Python is multi-paradigma #

Python “dwingt” je niet tot OOP. Je mixt vaak:

• functioneel/procedureel voor simpele transformaties,
• OOP voor structuur en domeinlogica.

De 4 pijlers van OOP (Python-interpretatie) #

1. Encapsulation (inkapseling) #

Idee: een object bewaakt zijn eigen data en regels.
Je wil voorkomen dat “iedereen overal zomaar aan de binnenkant zit te rommelen”.

Python-realiteit: Python heeft geen keiharde private velden zoals sommige talen. In plaats daarvan:

• _naam betekent: “intern, liever niet direct gebruiken”
• @property gebruik je om gecontroleerde toegang/validatie te doen

Voorbeeld:

class BankAccount:
    def __init__(self, balance=0):
        self._balance = balance  # "intern"

    @property
    def balance(self):
        return self._balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Amount must be positive")
        self._balance += amount

class BankAccount:
    def __init__(self, balance=0):
        self._balance = balance  # "intern"

    @property
    def balance(self):
        return self._balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Amount must be positive")
        self._balance += amount

Waarom dit fijn is:

• Je dwingt regels af (geen negatieve storting).
• Je voorkomt “random” bugs door ongeldige state.

2. Inheritance (overerving) #

Idee: je maakt een “is-een” relatie: een subtype dat gedrag erft en soms aanpast.

Voorbeeld: ElectricCar is een Car.

class Car:
    def start(self):
        return "Engine started"

class ElectricCar(Car):
    def start(self):
        return "Electric motor started"

class Car:
    def start(self):
        return "Engine started"

class ElectricCar(Car):
    def start(self):
        return "Electric motor started"

Python-tip: Overerving is handig, maar overdrijf niet.

• Te diepe inheritance trees worden snel onleesbaar.
• Vaak is compositie (objecten die andere objecten gebruiken) beter.

3. Polymorphism (veelvormigheid) #

Idee: verschillende objecten kunnen dezelfde “interface” hebben (zelfde methode-naam), en je code werkt met allemaal.

In Python gebeurt dit vaak via duck typing: “als het zich gedraagt als een eend…”

class Dog:
    def speak(self):
        return "woof"

class Cat:
    def speak(self):
        return "meow"

def make_it_speak(animal):
    print(animal.speak())

make_it_speak(Dog())
make_it_speak(Cat())

class Dog:
    def speak(self):
        return "woof"

class Cat:
    def speak(self):
        return "meow"

def make_it_speak(animal):
    print(animal.speak())

make_it_speak(Dog())
make_it_speak(Cat())

Je hoeft niet per se een formele interface te declareren; de afspraak is: er is een speak().

4) Abstraction (abstractie) #

Idee: je laat alleen zien wat nodig is en verbergt details.
Je wil dat gebruikers van je class denken in termen van wat iets doet, niet hoe.

Voorbeeld:

• Gebruiker roept deposit(50) aan.
• Hoe je dat intern opslaat/valideert maakt minder uit.

In Python is abstractie vaak:

• goede class- en methode-namen,
• een klein, duidelijk publiek API,
• intern kunnen details veranderen zonder dat gebruikerscode breekt.

Class vs object vs instance (met mini-voorbeeld) #

Definities (kort en helder)

• Class: het “blauwdruk”-idee (het type).
• Object / Instance: een concreet ding gemaakt van die class.
  • In de praktijk gebruiken mensen “object” en “instance” vaak door elkaar.

Voorbeeld:

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

alice = User("Alice")
bob = User("Bob")

print(alice.name)  # Alice
print(bob.name)    # Bob

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

alice = User("Alice")
bob = User("Bob")

print(alice.name)  # Alice
print(bob.name)    # Bob

Hier:

• User is de class.
• alice en bob zijn instances/objecten.
• name is een attribuut (state).
• __init__ is de initialisatie van een object.

“Real-world” analogie: Auto (state + gedrag) #

Denk aan een auto:

• state: brandstofniveau, snelheid, motor aan/uit
• gedrag: starten, accelereren, remmen, tanken

class Car:
    def __init__(self, fuel=0):
        self.fuel = fuel
        self.speed = 0
        self.engine_on = False

    def start(self):
        if self.fuel <= 0:
            raise ValueError("No fuel")
        self.engine_on = True

    def refuel(self, liters):
        if liters <= 0:
            raise ValueError("Liters must be positive")
        self.fuel += liters

    def accelerate(self, amount):
        if not self.engine_on:
            raise RuntimeError("Engine is off")
        if self.fuel <= 0:
            raise RuntimeError("Out of fuel")
        self.speed += amount
        self.fuel -= 1  # simpel model

class Car:
    def __init__(self, fuel=0):
        self.fuel = fuel
        self.speed = 0
        self.engine_on = False

    def start(self):
        if self.fuel <= 0:
            raise ValueError("No fuel")
        self.engine_on = True

    def refuel(self, liters):
        if liters <= 0:
            raise ValueError("Liters must be positive")
        self.fuel += liters

    def accelerate(self, amount):
        if not self.engine_on:
            raise RuntimeError("Engine is off")
        if self.fuel <= 0:
            raise RuntimeError("Out of fuel")
        self.speed += amount
        self.fuel -= 1  # simpel model

Wat je hier ziet:

• De auto bewaakt regels (niet accelereren met motor uit).
• De buitenwereld hoeft niet te weten hoe fuel precies afneemt; je gebruikt gewoon accelerate().

Dit is de basis van Objectgeoriënteerd programmeren. Een onmisbare stap voor een goede architectuur. Kijk daarom ook naar de volgende hoofdstukken om er voor te zorgen dat je dit daadwerkelijk goed kan toepassen.