Inkapseling en abstractie

Inkapseling en abstractie zijn fundamentele principes van objectgeoriënteerd programmeren (OOP) die helpen om complexiteit te beheersen en de code overzichtelijker te organiseren.

Inkapseling beperkt directe toegang tot de gegevens van een object, terwijl abstractie implementatiedetails verbergt en alleen essentiële functionaliteit beschikbaar maakt.

Inkapseling betekent dat je gegevens (attributen) en methoden binnen een klasse samenbrengt en directe toegang ertoe beperkt.

# Example of encapsulation
class Person:
    # Private attribute (indicated by double underscores)
    def __init__(self, name):
        self.__name = name

    # Public method to access the private attribute
    def get_name(self):
        return self.__name

person = Person("Alice")
# Accessing private data via a public method
print(person.get_name())

In Python worden private attributen aangeduid met dubbele underscores __. Ze zijn buiten de klasse niet rechtstreeks toegankelijk.

# Private attributes
class Car:
    def __init__(self, brand):
        self.__brand = brand  # Private attribute

    def get_brand(self):
        # Public method to access the private attribute
        return self.__brand

car = Car("Toyota")
print(car.get_brand())  # Outputs: Toyota

Abstractie verbergt de interne implementatiedetails van een klasse en maakt alleen de noodzakelijke functionaliteit beschikbaar voor de gebruiker.

# Example of abstraction
from abc import ABC, abstractmethod

# Abstract Base Class
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

# Subclass implementing the abstract method
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

circle = Circle(5)
print(circle.area())  # Outputs: 78.5

Abstracte klassen zijn klassen waarvan je niet rechtstreeks een instantie kunt maken. Ze worden gebruikt om een gemeenschappelijk koppelvlak voor hun subklassen te definiëren.

# Abstract Base Class with multiple subclasses
from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("Dog barks")

class Cat(Animal):
    def speak(self):
        print("Cat meows")

dog = Dog()
cat = Cat()
dog.speak()  # Outputs: Dog barks
cat.speak()  # Outputs: Cat meows

Inkapseling en abstractie hangen nauw samen, maar zijn verschillende concepten:

• Inkapseling: Beperkt de toegang tot gegevens binnen een klasse.
• Abstractie: Verbergt implementatiedetails en biedt een duidelijk koppelvlak.

Dit zijn enkele belangrijke voordelen:

• Verbetert de beveiliging en onderhoudbaarheid van de code.
• Stimuleert modulaire en herbruikbare code.
• Maakt de code gemakkelijker te lezen en te begrijpen.

Dit zijn enkele fouten die je moet vermijden:

• Private attributen rechtstreeks benaderen in plaats van getter- en settermethoden te gebruiken.
• Rechtstreeks een instantie van abstracte klassen maken.
• Niet alle abstracte methoden in subklassen implementeren.

In deze les heb je het volgende geleerd:

• Wat inkapseling is en hoe je met private attributen de toegang tot gegevens beperkt.
• Wat abstractie is en hoe je abstracte klassen gebruikt om gemeenschappelijke koppelvlakken te definiëren.
• Wat de verschillen en voordelen van inkapseling en abstractie zijn.

Goed gedaan! Laten we doorgaan naar het volgende onderwerp.