Czym jest abstrakcja w programowaniu?

Kiedy piszesz print("hi"), nie myślisz o tym, jak te litery trafiają na ekran. Pod tą jedną linią Python zamienia tekst na bajty i prosi system operacyjny o ich zapisanie, system operacyjny przekazuje je do terminala, a terminal rysuje każdą literę w pikselach za pomocą czcionki. Każda warstwa daje warstwie powyżej prostą obietnicę i ukrywa, jak ją spełnia. To ukrywanie jest abstrakcją, a każdy program stoi na wielu takich warstwach.

Poziomy abstrakcji

Każdy poziom jest zbudowany z poziomu poniżej i można go zrozumieć bez niego. Możesz pisać działający kod w Pythonie, nie wiedząc, czym jest blok dysku, a system operacyjny może zapisać plik, nie wiedząc, że zawiera on kod w Pythonie.

Jak działa abstrakcja w kodzie

Programiści budują własne warstwy na dwa główne sposoby.

Abstrakcja proceduralna to funkcja. Jej nazwa, parametry i zwracana wartość tworzą interfejs; ciało to ukryty szczegół. Gdy average(scores) już istnieje, reszta programu korzysta z niej, nie czytając, jak dodaje i dzieli.

Abstrakcja danych definiuje typ przez to, co można z nim zrobić, a nie przez to, jak przechowuje dane. Kolejka to "dodaj na końcu, weź z początku". To, jak elementy leżą w pamięci, jest prywatną decyzją:

from collections import deque

class Queue:
    """First in, first out. Callers only see add() and next()."""
    def __init__(self):
        self._items = deque()     # swap this for a list and callers never notice
    def add(self, item):
        self._items.append(item)
    def next(self):
        return self._items.popleft()
    def __len__(self):
        return len(self._items)

orders = Queue()
for dish in ["soup", "pasta", "cake"]:
    orders.add(dish)
while len(orders):
    print("serving", orders.next())

serving soup
serving pasta
serving cake

Kod na dole nic nie wie o deque. Jeśli zastąpisz go zwykłą listą i pop(0), wynik będzie identyczny, tylko wolniejszy przy długich kolejkach, bo usunięcie pierwszego elementu listy przesuwa wszystkie pozostałe. Interfejs się nie zmienił, więc nic poza klasą nie wymagało zmian.

Klasy abstrakcyjne i interfejsy

W programowaniu obiektowym abstrakcja zwykle oznacza określenie, co ma robić rodzina klas, i pozostawienie jak każdej klasie z osobna. W Pythonie moduł abc oznacza metodę jako abstrakcyjną; klasy z niezaimplementowaną metodą abstrakcyjną nie da się utworzyć:

from abc import ABC, abstractmethod

class Notifier(ABC):
    @abstractmethod
    def send(self, to, text):
        """Every notifier must say how it sends a message."""

class Email(Notifier):
    def send(self, to, text):
        print(f"email to {to}: {text}")

class SMS(Notifier):
    def send(self, to, text):
        print(f"sms to {to}: {text}")

def remind(notifier, user):
    notifier.send(user, "Your package arrives today")

remind(Email(), "ana@example.com")
remind(SMS(), "+15550100")
try:
    Notifier()
except TypeError:
    print("Notifier is abstract: create an Email or an SMS instead")

email to ana@example.com: Your package arrives today
sms to +15550100: Your package arrives today
Notifier is abstract: create an Email or an SMS instead

remind() zależy tylko od abstrakcji: od czegokolwiek, co ma metodę send. Dodanie powiadomień push oznacza napisanie jednej nowej klasy, a remind() pozostaje nietknięte. Ten ostatni krok, czyli jedno wywołanie uruchamiające inny kod dla różnych klas, to polimorfizm: abstrakcja definiuje wspólny interfejs, a polimorfizm sprawia, że on działa.

Java ma te same narzędzia w postaci słów kluczowych:

interface Notifier {
    void send(String to, String text);
}

class Email implements Notifier {
    public void send(String to, String text) { /* talk to the mail server */ }
}

Napisanie new Notifier() to błąd kompilacji, bo interfejs nie ma żadnej implementacji do uruchomienia. Dokumentacja szczegółowo opisuje klasy abstrakcyjne i interfejsy w Javie.

Abstrakcja a enkapsulacja

Te dwie idee pojawiają się razem tak często, że łatwo je pomylić.

Abstrakcja decyduje, które operacje pokazać; enkapsulacja pilnuje, żeby reszta pozostała ukryta. Powyższa klasa Queue robi jedno i drugie: add i next to abstrakcja, a podkreślnik w _items to enkapsulacja.

Dziurawe abstrakcje i inne błędy

Joel Spolsky nazwał w 2002 roku prawo dziurawych abstrakcji (leaky abstractions): każda nietrywialna abstrakcja przepuszcza część ukrytych szczegółów. Klasycznym przeciekiem są liczby zmiennoprzecinkowe. Wyglądają jak zwykłe ułamki dziesiętne, dopóki nie wyjdzie na wierzch binarny zapis pod spodem:

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)

0.30000000000000004
False

Ani 0,1, ani 0,2 nie da się dokładnie zapisać w binarnych bitach, więc suma jest odrobinę niedokładna. Możesz latami używać liczb float, nie myśląc o tym, ale nie w nieskończoność, i dlatego warto znać jedną warstwę poniżej tej, na której pracujesz.

Dwa kolejne błędy są częste:

• Zbyt wczesna abstrakcja. Hierarchia klas zbudowana na przypadki, które nigdy nie nadchodzą, to dodatkowy kod do czytania i zmieniania. Sandi Metz ujęła to tak: "duplikacja jest dużo tańsza niż zła abstrakcja".
• Mylenie abstrakcji ze słowem kluczowym abstract. Klasy abstrakcyjne to tylko jedno narzędzie. Każda dobrze nazwana funkcja też jest abstrakcją.

Co dalej

Przeczytaj o enkapsulacji i polimorfizmie, żeby uzupełnić obraz programowania obiektowego. Strona o systemie operacyjnym pokazuje największą abstrakcję, na której polegają twoje programy. Żeby poćwiczyć, kurs Python od początku buduje klasy i funkcje, a kurs Java omawia klasy abstrakcyjne i interfejsy.