Что такое абстракция в программировании?

Когда ты пишешь print("hi"), ты не думаешь о том, как эти буквы попадают на экран. Под этой одной строкой Python превращает текст в байты и просит операционную систему записать их, операционная система передаёт их терминалу, а терминал рисует каждую букву пикселями с помощью шрифта. Каждый слой даёт слою над ним простое обещание и скрывает, как его выполняет. Это сокрытие и есть абстракция, и любая программа стоит на множестве таких слоёв.

Уровни абстракции

Каждый уровень построен из нижнего, и его можно понять без него. Можно писать работающий код на Python, не зная, что такое блок диска, а операционная система может сохранить файл, не зная, что в нём код на Python.

Как абстракция работает в коде

Программисты строят свои слои двумя основными способами.

Процедурная абстракция это функция. Её имя, параметры и возвращаемое значение составляют интерфейс; тело это скрытая деталь. Как только появилась average(scores), остальная программа пользуется ею, не читая, как она складывает и делит.

Абстракция данных определяет тип через то, что с ним можно делать, а не через то, как он хранит данные. Очередь это «добавить в конец, взять из начала». Как элементы лежат в памяти, решается внутри:

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

Код внизу ничего не знает о deque. Если заменить её обычным списком и pop(0), вывод будет тем же, только для длинных очередей медленнее, потому что удаление первого элемента списка сдвигает все остальные элементы. Интерфейс остался прежним, поэтому ничего вне класса менять не пришлось.

Абстрактные классы и интерфейсы

В объектно-ориентированном программировании абстракция обычно означает, что указывается, что должно делать семейство классов, а как, оставляется каждому классу. В Python модуль abc помечает метод как абстрактный; класс с нереализованным абстрактным методом нельзя создать:

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() зависит только от абстракции: от чего угодно с методом send. Чтобы добавить push-уведомления, нужно написать один новый класс, а remind() остаётся нетронутой. Этот последний шаг, когда один вызов выполняет разный код для разных классов, называется полиморфизмом: абстракция задаёт общий интерфейс, а полиморфизм заставляет его работать.

В Java те же инструменты выражены ключевыми словами:

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

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

Запись new Notifier() это ошибка компиляции, потому что у интерфейса нет реализации, которую можно выполнить. В документации подробно описаны абстрактные классы и интерфейсы в Java.

Абстракция и инкапсуляция: в чём разница

Эти две идеи так часто встречаются вместе, что их легко перепутать.

Абстракция решает, какие операции показать; инкапсуляция следит, чтобы остальное оставалось скрытым. Queue выше делает и то и другое: add и next это абстракция, а подчёркивание в _items это инкапсуляция.

Протекающие абстракции и другие ошибки

Джоэл Спольски в 2002 году сформулировал закон протекающих абстракций: любая нетривиальная абстракция пропускает часть скрытых деталей наружу. Классический пример утечки это числа с плавающей точкой. Они выглядят как обычные десятичные дроби, пока сквозь них не проступит двоичное хранение:

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

0.30000000000000004
False

Ни 0,1, ни 0,2 нельзя точно сохранить в двоичных битах, поэтому сумма получается чуть неточной. Можно годами пользоваться числами с плавающей точкой и не думать об этом, но не вечно, и поэтому полезно знать один слой ниже того, в котором ты работаешь.

Ещё две ошибки встречаются часто:

• Слишком ранняя абстракция. Иерархия классов, построенная под случаи, которые так и не наступили, это лишний код, который нужно читать и менять. Сэнди Метц сформулировала это так: «дублирование обходится гораздо дешевле, чем неправильная абстракция».
• Смешение абстракции с ключевым словом abstract. Абстрактные классы это лишь один инструмент. Любая функция с хорошим именем тоже абстракция.

Что читать дальше

Прочитай про инкапсуляцию и полиморфизм, чтобы завершить картину объектно-ориентированного программирования. Страница про операционную систему показывает самую большую абстракцию, на которую опираются твои программы. Для практики курс Python с самого начала учит строить классы и функции, а курс Java разбирает абстрактные классы и интерфейсы.