Сочетания клавиш

Нажмите ← или → для навигации между главами

Нажмите S или / для поиска по книге

Нажмите ?, чтобы показать эту справку

Нажмите Esc, чтобы скрыть эту справку

Характеристики объектно-ориентированных языков

В сообществе программистов нет единого мнения о том, какие возможности должны быть у языка, чтобы считаться объектно-ориентированным. Rust находится под влиянием многих парадигм программирования, включая ООП; например, мы изучали возможности, пришедшие из функционального программирования, в главе 13. Вероятно, объектно-ориентированные языки разделяют некоторые общие характеристики — а именно объекты, инкапсуляцию и наследование. Давайте посмотрим, что означает каждая из этих характеристик и поддерживает ли её Rust.

Объекты содержат данные и поведение

Книга Design Patterns: Elements of Reusable Object-Oriented Software Эриха Гаммы, Ричарда Хелма, Ральфа Джонсона и Джона Влиссидеса (Addison-Wesley, 1994), в обиходе называемая книгой Банды четырёх, представляет собой каталог объектно-ориентированных шаблонов проектирования. Она определяет ООП следующим образом:

Объектно-ориентированные программы состоят из объектов. Объект объединяет в себе данные и процедуры, которые оперируют этими данными. Процедуры обычно называют методами или операциями.

Используя это определение, Rust является объектно-ориентированным: структуры и перечисления имеют данные, а блоки impl предоставляют методы для структур и перечислений. Хотя структуры и перечисления с методами не называются объектами, они предоставляют ту же функциональность, согласно определению объектов Бандой четырёх.

Инкапсуляция, скрывающая детали реализации

Ещё один аспект, обычно связанный с ООП, — это идея инкапсуляции, которая означает, что детали реализации объекта недоступны для кода, использующего этот объект. Следовательно, единственный способ взаимодействия с объектом — через его публичный API; код, использующий объект, не должен иметь возможности проникать во внутренности объекта и напрямую изменять данные или поведение. Это позволяет программисту изменять и рефакторить внутренности объекта, не нуждаясь в изменении кода, который использует объект.

Мы обсуждали, как управлять инкапсуляцией в главе 7: мы можем использовать ключевое слово pub, чтобы решить, какие модули, типы, функции и методы в нашем коде должны быть публичными, а всё остальное по умолчанию является приватным. Например, мы можем определить структуру AveragedCollection, которая имеет поле, содержащее вектор значений i32. Структура также может иметь поле, которое содержит среднее значение значений в векторе, что означает, что среднее не нужно вычислять по запросу каждый раз, когда оно кому-то нужно. Другими словами, AveragedCollection будет кэшировать вычисленное среднее для нас. Листинг 18-1 содержит определение структуры AveragedCollection.

Имя файла: src/lib.rs
pub struct AveragedCollection {
    list: Vec<i32>,
    average: f64,
}
Листинг 18-1: Структура AveragedCollection, которая поддерживает список целых чисел и среднее значение элементов в коллекции

Структура помечена как pub, чтобы другой код мог её использовать, но поля внутри структуры остаются приватными. Это важно в данном случае, потому что мы хотим гарантировать, что всякий раз, когда значение добавляется или удаляется из списка, среднее также обновляется. Мы делаем это, реализуя методы add, remove и average для структуры, как показано в листинге 18-2.

Имя файла: src/lib.rs
pub struct AveragedCollection {
    list: Vec<i32>,
    average: f64,
}

impl AveragedCollection {
    pub fn add(&mut self, value: i32) {
        self.list.push(value);
        self.update_average();
    }

    pub fn remove(&mut self) -> Option<i32> {
        let result = self.list.pop();
        match result {
            Some(value) => {
                self.update_average();
                Some(value)
            }
            None => None,
        }
    }

    pub fn average(&self) -> f64 {
        self.average
    }

    fn update_average(&mut self) {
        let total: i32 = self.list.iter().sum();
        self.average = total as f64 / self.list.len() as f64;
    }
}
Листинг 18-2: Реализации публичных методов add, remove и average для AveragedCollection

Публичные методы add, remove и average — единственные способы доступа к данным в экземпляре AveragedCollection или их изменения. Когда элемент добавляется в list с помощью метода add или удаляется с помощью метода remove, реализации каждого из них вызывают приватный метод update_average, который также обрабатывает обновление поля average.

Мы оставляем поля list и average приватными, чтобы внешний код не мог напрямую добавлять или удалять элементы в поле list или из него; в противном случае поле average могло бы рассинхронизироваться при изменении list. Метод average возвращает значение в поле average, позволяя внешнему коду читать average, но не изменять его.

Поскольку мы инкапсулировали детали реализации структуры AveragedCollection, мы можем легко изменить аспекты, такие как структура данных, в будущем. Например, мы могли бы использовать HashSet<i32> вместо Vec<i32> для поля list. До тех пор, пока сигнатуры публичных методов add, remove и average остаются прежними, код, использующий AveragedCollection, не нужно было бы менять. Если бы мы сделали list публичным вместо этого, это не обязательно было бы так: HashSet<i32> и Vec<i32> имеют разные методы для добавления и удаления элементов, поэтому внешнему коду, вероятно, пришлось бы измениться, если бы он изменял list напрямую.

Если инкапсуляция является обязательным аспектом для того, чтобы язык считался объектно-ориентированным, то Rust соответствует этому требованию. Возможность использовать pub или не использовать его для разных частей кода обеспечивает инкапсуляцию деталей реализации.

Наследование как система типов и как совместное использование кода

Наследование — это механизм, с помощью которого объект может наследовать элементы из определения другого объекта, таким образом получая данные и поведение родительского объекта без необходимости определять их снова.

Если язык должен иметь наследование, чтобы быть объектно-ориентированным, то Rust не является таким языком. Нет способа определить структуру, которая наследует поля и реализации методов родительской структуры, без использования макроса.

Однако, если вы привыкли иметь наследование в своём наборе инструментов программирования, вы можете использовать другие решения в Rust, в зависимости от причины, по которой вы обращаетесь к наследованию.

Вы бы выбрали наследование по двум основным причинам. Одна из них — повторное использование кода: вы можете реализовать определённое поведение для одного типа, и наследование позволяет вам повторно использовать эту реализацию для другого типа. Вы можете сделать это ограниченным образом в коде на Rust, используя реализации методов трейтов по умолчанию, которые вы видели в листинге 10-14, когда мы добавили реализацию по умолчанию метода summarize для трейта Summary. Любой тип, реализующий трейт Summary, будет иметь метод summarize, доступный для него без какого-либо дополнительного кода. Это похоже на то, как родительский класс имеет реализацию метода, и наследующий дочерний класс также имеет реализацию метода. Мы также можем переопределить реализацию метода summarize по умолчанию, когда реализуем трейт Summary, что похоже на то, как дочерний класс переопределяет реализацию метода, унаследованного от родительского класса.

Другая причина использования наследования связана с системой типов: чтобы позволить дочернему типу использоваться в тех же местах, что и родительский тип. Это также называется полиморфизмом, что означает, что вы можете подставлять несколько объектов друг за друга во время выполнения, если они разделяют определённые характеристики.

Полиморфизм

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

Rust вместо этого использует обобщения для абстрагирования над различными возможными типами и ограничения трейтов для наложения ограничений на то, что эти типы должны предоставлять. Это иногда называют ограниченным параметрическим полиморфизмом.

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

По этим причинам Rust использует другой подход — использование трейт-объектов вместо наследования для достижения полиморфизма во время выполнения. Давайте посмотрим, как работают трейт-объекты.