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

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

Основы объектно-ориентированного программирования (ООП)

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

Инкапсуляция

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

Полиморфизм

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

Наследование

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

Классы и объекты

Классы и Объекты - две стороны одной медали. Классы - это определение, а Объекты - это фактическая реализация. У вас есть Animal Class, который определяет, что такое Animal, и ваш animal1 Object это то, с чем вы работаете в своей программе. Наличие объекта означает, что индивидуальная реализация класса является автономной и абстрагируется от класса. Однако многие люди будут использовать эти слова как синонимы.

Абстракция

Абстракция говорит сама за себя. Цель ООП - абстрагировать наш код, чтобы мы могли сосредоточиться на концепциях более высокого уровня вместо того, чтобы увязнуть в реализации базовых идей. Объект - это реализация, а Класс - это абстракция. Инкапсуляция позволяет нам объединять концептуальные единицы в один объект, который представляет собой абстракцию данных и методов. Все эти концепции в конечном итоге приводят к дальнейшей абстракции по сравнению с процедурным программированием.

Для чего подходит ООП?

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

Углубляясь в данные

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

Уменьшить и использовать повторно

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

Добавление таких принципов, как наследование и полиморфизм, означает, что вместо того, чтобы принимать необработанные данные, данный класс или объект может работать с другими формами объектов. По мере того, как объекты становятся все более и более абстрактными, они становятся все более и более динамичными. number может быть int, float, double или любым другим числом, поддерживаемым языком.

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

Типы ООП

Существует бесчисленное множество языков с запекшимися концепциями ООП. Практически любой язык, новее 80-х годов или около того, будет иметь какой-то вид ООП. Даже в действительно старых вещах были закреплены концепции ООП.

Большая разница в том, насколько язык привязан к каждой концепции. Некоторые языки, такие как Java или C #, требуют ООП, и все его принципы используются даже в самых тривиальных программах, другие, такие как Lua или Perl, допускают ООП, но не требуют этого. Такие языки, как Python, построены на концепциях ООП, где каждый базовый тип данных является объектом, но не обязательно требует навыков ООП. Разные философии приводят к разным функциональным возможностям и вариантам использования.

Чем плохо ООП?

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

Абстракция против. Реальность

Слишком большая абстракция ведет к полному отрыву от реальности. По мере того как классы уступают место шаблонам, абстрактным классам и всевозможным другим абстрактным идеям, код становится все труднее и труднее поддерживать. Зеленые программисты Java печально известны тем, что они написали программу, состоящую из 10 строк практически на любом другом языке и сотен на Java. «Hello World» не требует полиморфизма или наследования. Ему не нужны шаблоны или подробная обработка ошибок.

Излишняя абстракция просто приводит к невозможности поддержки кода. Вам не нужно отслеживать количество волос на каждой овце, если вы просто пытаетесь их сосчитать. Незначительные изменения приводят к путанице. Изменение класса animal может привести к непреднамеренному поведению в производном классе вниз по цепочке. Это разъединение приводит к незнанию, где находится часть, которую нужно изменить, или к путанице в отношении того, где что-то было изменено.

Снося хорошее с плохим

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

В некоторых кругах Java стала почти осужденной из-за того, что она допускает ужасные методы кодирования. Сам по себе язык неплох, но привычки, которые он поощряет, прямо или косвенно, сделали его рыжеволосым, ублюдочным пасынком языков в большинстве магазинов. Java абстрагировалась до абсурда и с тех пор служит предупреждением для других языков.

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

Заключение

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

Первоначально опубликовано на https://somedudesays.com.