К сожалению, код (и Интернет) говорят нет.

Самая большая путаница и разногласия, по-видимому, связаны с композицией и наследованием, часто резюмируемой в мантре «предпочитайте композицию наследованию». Давайте поговорим об этом.

Мантры считаются вредными

Как эвристика, «предпочесть композицию наследованию» — это нормально, однако я не фанат мантр. Хотя они часто содержат зерно истины, люди слишком легко слышат лозунг, не понимая его источника или контекста, и, таким образом, избегают думать самостоятельно, а это никогда не заканчивается хорошо.

Я также не являюсь поклонником нелепых кликбейтных заголовков, таких как «Наследование — это зло» ⁶ , особенно когда автор пытается подкрепить такое возмутительное утверждение ненадлежащим использованием наследования… а затем обвиняет его. Как плотник, заявляющий, что молотки бесполезны, потому что они плохо закручивают шурупы.

Начнем с основ.

Определения

Вот определение объектно-ориентированного программирования, которое я буду использовать в оставшейся части статьи: предположим, что у нас есть «классический» язык ООП, то есть такой, который поддерживает классы с полями, методами и одиночным наследованием. Никаких интерфейсов, никаких примесей, никаких аспектов, никакого множественного наследования, никаких делегатов, никаких замыканий, никаких лямбда-выражений, ничего, кроме основ:

• Класс: именованное понятие в доменном пространстве с необязательным суперклассом, определенным как набор полей и методов.
• Поле: именованное свойство некоторого типа, которое может ссылаться на другой объект (см. состав)
• Метод: именованная функция или процедура с параметрами или без них, реализующая некоторое поведение класса.
• Наследование: класс может наследовать — использовать по умолчанию — поля и методы своего суперкласса. Наследование является транзитивным, поэтому класс может наследовать от другого класса, который наследуется от другого класса, и так далее, вплоть до базового класса (обычно Object, возможно, неявного/отсутствующего). Подклассы могут переопределять некоторые методы и/или поля, чтобы изменить поведение по умолчанию.
• Состав: когда тип поля является классом, поле будет содержать ссылку на другой объект, тем самым создавая ассоциативное отношение между ними. Не вдаваясь в нюансы разницы между простой ассоциацией, агрегацией и композицией, давайте интуитивно определим композицию как случай, когда класс использует другой объект для обеспечения части или всей своей функциональности.
• Инкапсуляция: взаимодействуя с объектами, а не напрямую с реализацией методов и полей, мы скрываем и защищаем реализацию класса. Если потребитель ничего не знает об объекте, кроме его открытого интерфейса, он не может полагаться на какие-либо детали внутренней реализации.

Наследование является основным

Наследование является фундаментальным для объектно-ориентированного программирования. Язык программирования может иметь объекты и сообщения, но без наследования он не является объектно-ориентированным (просто «объектно-ориентированным», но все же полиморфным).

…и состав

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

(Инкапсуляция тоже имеет фундаментальное значение, но мы не будем здесь подробно о ней говорить. )

Так о чем суета?

И композиция, и наследование фундаментальны, так в чем же дело?

Большое дело в том, чтобы думать, что одно может заменить другое во всех случаях, или что одно лучше или хуже другого. Как и во всем остальном в разработке программного обеспечения, здесь приходится идти на компромиссы.

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

Семантика наследования

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

Механика наследования

Наследование захватывает механику, кодируя представление данных (полей) и поведения (методов) класса и делая его доступным для повторного использования и расширения в подклассах.

Двойное назначение наследования ⁷ в большинстве современных ООП-языков, по моему мнению, является причиной наибольшей путаницы. Многие думают, что «повторное использование кода» — основная цель наследования, но это не единственная его цель. Чрезмерный акцент на повторном использовании может привести к трагически ошибочным проектам. Давайте посмотрим на пару примеров.

Как неправильно использовать наследование — пример 1

Начнем с простого и чрезвычайно распространенного примера неправильного использования наследования:

 class Stack extends ArrayList {
    public void push(значение объекта) {…}
    общедоступный объект pop() { … }
}
 

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

Вы можете переопределить все ненужные методы и, возможно, адаптировать некоторые полезные (например, очистку), но для того, чтобы скрыть ошибку моделирования, потребуется много работы. На самом деле три ошибки моделирования, одна семантическая, одна механическая, одна и та, и другая:

1. Семантически утверждение «Стек — это ArrayList» неверно; Stack не является правильным подтипом ArrayList. Предполагается, что стек обеспечивает соблюдение принципа «последним пришел — первым вышел» — ограничение, которое легко удовлетворяется интерфейсом push/pop, но не обеспечивается интерфейсом ArrayList.
2. Механически наследование от ArrayList нарушает инкапсуляцию; использование ArrayList для хранения коллекции объектов стека — это выбор реализации, который должен быть скрыт от потребителей.
3. Наконец, реализация стека путем наследования от ArrayList представляет собой междоменное отношение: ArrayList — коллекция с произвольным доступом; Стек — это концепция организации очереди со специально ограниченным (неслучайным) доступом ⁸ . Это разные области моделирования.

Последняя проблема важна, но немного тонка, поэтому давайте рассмотрим ее на другом примере.

Как неправильно использовать наследование — пример 2

Создание класса предметной области путем наследования от класса реализации является распространенным злоупотреблением наследованием. Например, предположим, что мы хотим что-то сделать с определенным сегментом наших клиентов. Самый простой и очевидный способ — создать подкласс ArrayList, назвать его CustomerGroup и начать программировать, верно?

Неправильно. Это будут отношения междоменного наследования, и их следует избегать:

1. ArrayList уже является подклассом списка, набор утилит — класс реализации .
2. CustomerGroup — это еще один подкласс — класс домена .
3. Классы домена должны использовать классы реализации , а не наследоваться от них.

Пространство реализации должно быть невидимым на уровне домена. Когда мы думаем о том, что делает наше программное обеспечение, мы работаем на уровне предметной области; мы не хотим отвлекаться на детали того, как он работает. Если мы сосредоточимся только на «повторном использовании кода» через наследование, мы будем постоянно попадать в эту ловушку.

Одиночное наследование не является проблемой

Одиночное наследование по-прежнему является наиболее распространенной моделью ООП; одиночное наследование обязательно является наследованием реализации, что может привести к сильной связи между классами. Проблема, по-видимому, заключается в том, что у нас есть только один путь наследования, который можно использовать для моделирования как наших механических, так и семантических потребностей. Если вы используете его для одного, вы не можете использовать его для другого. Так не решает ли множественное наследование эту проблему?

№ . Отношения наследования не должны пересекать границы домена (домен реализации и домен приложения). Наследование CustomerGroup от ArrayList, а также (скажем) от DemographicSegment запутывает два субдомена, запутывая таксономию.

Предпочтительное (по крайней мере для меня!) решение состоит в том, чтобы наследовать от служебных классов столько, сколько необходимо для реализации ваших механических структур, а затем использовать эти структуры в классах предметной области посредством композиции, а не наследования. Позвольте мне повторить это:

Если вы не создаете класс реализации, вы не должны наследовать от класса реализации.

Это одна из самых распространенных проблем новичков — потому что это так удобно! — а причины, по которым это неправильно, нечасто обсуждаются в литературе по программированию, поэтому я повторю еще раз: ваши классы предметной области должны использовать класса реализации, а не быть одним из них. Разделяйте эти таксономии/домены.

Итак, когда и как мы должны использовать наследование?

Использование скважины наследства

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

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

Как решить: состав или наследство?

Если у вас есть ситуация, когда сработает либо композиция, либо наследование, рассмотрите возможность разделения обсуждения дизайна на две части:

1. Представление/реализация концепций вашей предметной области является одним измерением
2. Семантика понятий вашей предметной области и их связь друг с другом — это второе измерение

В общем, наследование в пределах одного из этих измерений — это нормально. Проблема возникает, когда мы забываем разделить два измерения и начинаем наследовать через межпространственные границы.

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

Ничто не заменит объектное моделирование и критическое дизайнерское мышление. Но если вам нужны какие-то рекомендации, рассмотрите их —

Наследование следует использовать только в следующих случаях:

1. Оба класса находятся в одном логическом домене
2. Подкласс является правильным подтипом надкласса
3. Реализация суперкласса необходима или подходит для подкласса
4. Улучшения, сделанные подклассом, в основном аддитивны.

Бывают моменты, когда все эти вещи сходятся:

• Моделирование предметной области более высокого уровня
• Фреймворки и расширения фреймворка
• Дифференциальное программирование

Если вы не делаете ни одной из этих вещей, вам, вероятно, не понадобится очень часто наследование классов. «Предпочтение» композиции — это не вопрос «лучше», это вопрос «наиболее подходящего» для ваших нужд в конкретном контексте.

Надеемся, что эти рекомендации помогут вам заметить разницу.

Удачного кодирования!

Приложение

Особая благодарность следующим мыслителям за ценный вклад и комментарии: Питу Ходжсону, Тиму Брауну, Скотту Робинсону, Мартину Фаулеру, Минди Ор, Шону Ньюэму, Сэму Гибсону и Махендре Кария.

1. Первый официально объектно-ориентированный язык SIMULA 67 родился в 1967 году. Объектно-ориентированному программированию исполнилось 48 лет!
2. Программисты систем и приложений приняли C++ в середине 1980-х годов, но повсеместному распространению ООП пришлось ждать еще десять лет.
3. да, я упрощаю, игнорируя слушателей/делегатов событий/и т.д.; стараясь сделать эту статью короткой!
4. Amazon заявляет о 24 777 книгах по теме объектно-ориентированного программирования на момент написания этой статьи
5. Поиск Google требует около 8 миллионов результатов по точной фразе «объектно-ориентированное программирование» на момент написания этой статьи
6. Поиск Google дает примерно 37 600 результатов для точной фразы «наследование — это зло» на момент написания этой статьи
7. Семантика (интерфейсы) и механика (представление) могут быть разделены за счет дополнительной языковой сложности; см., например, спецификацию языка D CJ Date и Hugh Darwen.
8. С некоторой грустью отметим, что класс Stack в Java наследуется от Vector.
9. Проектирование классов для повторного использования посредством наследования выходит за рамки этой статьи. Просто имейте в виду, что потребители экземпляров и подклассов имеют разные потребности, обе из которых должны быть удовлетворены вашим дизайном класса.

Состав Определение и значение | Британский словарь

^{состав /ˌkɑːmpəˈzɪʃən/ сущ.}

множественное число композиции

^состав

/ˌkɑːmpəˈzɪʃən/

существительное

множественное число композиции

Британское словарное определение КОМПОЗИЦИИ

1 

[не в счет]

:

способ, которым что-то скомпоновано или устроено

[+] больше примеров [-] скрыть примеры [+] Примеры предложений [-] Скрыть примеры

:

сочетание частей или элементов, составляющих что-либо

• Каждый камень имеет немного другой состав .