Wprowadzenie do enkapsulacji i abstrakcji

Enkapsulacja i abstrakcja to podstawowe zasady programowania obiektowego (OOP), które pomagają zarządzać złożonością i lepiej organizować kod.

Enkapsulacja ogranicza bezpośredni dostęp do danych obiektu, a abstrakcja ukrywa szczegóły implementacji i udostępnia tylko niezbędne funkcje.

Czym jest enkapsulacja?

Enkapsulacja polega na połączeniu danych (atrybutów) i metod w obrębie klasy oraz ograniczeniu bezpośredniego dostępu do nich.

# 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())

Atrybuty prywatne

W języku Python atrybuty prywatne oznacza się podwójnym podkreśleniem __. Nie można uzyskać do nich bezpośredniego dostępu spoza klasy.

# 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

Czym jest abstrakcja?

Abstrakcja ukrywa wewnętrzne szczegóły implementacji klasy i udostępnia użytkownikowi tylko niezbędną funkcjonalność.

# 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

Klasy abstrakcyjne

Klasy abstrakcyjne to klasy, których nie można bezpośrednio utworzyć. Służą do definiowania wspólnego interfejsu dla klas pochodnych.

# 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

Enkapsulacja a abstrakcja

Enkapsulacja i abstrakcja są ściśle powiązanymi, ale odrębnymi pojęciami:

• Enkapsulacja: Ogranicza dostęp do danych wewnątrz klasy.
• Abstrakcja: Ukrywa szczegóły implementacji i udostępnia przejrzysty interfejs.

Zalety enkapsulacji i abstrakcji

Oto niektóre z najważniejszych zalet:

• Poprawiają bezpieczeństwo i łatwość utrzymania kodu.
• Sprzyjają tworzeniu modularnego kodu wielokrotnego użytku.
• Ułatwiają czytanie i zrozumienie kodu.

Typowe błędy związane z enkapsulacją i abstrakcją

Oto błędy, których należy unikać:

• Uzyskiwanie bezpośredniego dostępu do atrybutów prywatnych zamiast używania metod getter i setter.
• Bezpośrednie tworzenie instancji klas abstrakcyjnych.
• Nieimplementowanie wszystkich metod abstrakcyjnych w klasach pochodnych.

Czego się nauczyliśmy?

W tej lekcji dowiedzieli się Państwo:

• Czym jest enkapsulacja i jak ograniczać dostęp do danych za pomocą atrybutów prywatnych.
• Czym jest abstrakcja i jak używać klas abstrakcyjnych do definiowania wspólnych interfejsów.
• Jakie są różnice między enkapsulacją a abstrakcją oraz jakie korzyści przynoszą oba te mechanizmy.

Świetnie! Przejdźmy do następnego tematu.