Что такое объектно ориентированный язык программирования
Перейти к содержимому

Что такое объектно ориентированный язык программирования

  • автор:

Что такое объектно-ориентированное программирование (ООП)?

Объектно-ориентированное программирование определяет режим программирования, который ориентируется на структурные объекты со связанными свойствами.

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

Осмысливая код с точки зрения объектов и классов, разработчики могут создавать программное обеспечение более гибко и интуитивно понятно, чем в противном случае. Этот метод организации долгое время использовался для написания чистого, поддерживаемого и, что наиболее важно, повторно используемого кода.

Что такое объектно-ориентированное программирование?

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

    Процедурное программирование работает с помощью пошаговых инструкций. Структурированное программирование немного сложнее, оно использует потоки управления, такие как операторы if/then/else и циклы while/for.

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

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

4 основных строительных блока ООП

Четыре фундаментальных строительных блока охватывают принцип работы объектно-ориентированного программирования: классы, атрибуты, методы и объекты.

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

Атрибуты (или переменные) относятся к характеристикам объекта. Внешний вид, состояние и другие качественные признаки являются общими атрибутами объекта. Атрибуты класса в сочетании с экземплярами объекта отличают объекты друг от друга. Следующая программа демонстрирует объявление класса в Python:

Класс Автомобиль:
def init (я, цвет, тип):
self.color = цвет
self.type = тип

Здесь «я» представляет экземпляр класса для будущих ссылок на атрибуты и методы объекта. А «цвет» и «тип» представляют собой атрибуты класса.

Программисты также должны определять методы вместе с атрибутами. Методы инкапсулируют функции, которые обрабатывают данные и поведение экземпляра объекта.

В автомобиле метод вождения может быть уместен. Вы можете определить такой метод прямо под определениями атрибутов автомобиля.

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

защитный диск (сам)
print(‘Я за рулем’ + self.color + self.type)

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

автомобиль = Автомобиль(‘красный’, ‘Седан’)

Приведенный выше код формально установит конкретный экземпляр уникального автомобильного объекта.

Затем вы сможете увидеть, как метод привода работает в действии.

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

1. Инкапсуляция
Инкапсуляция — это связывание состояния и поведения объекта вместе. Это происходит, когда атрибуты и методы заключены в единый модуль и/или класс. Из-за инкапсуляции поля класса недоступны для публики напрямую. Кроме того, инкапсуляция обеспечивает гибкость и удобство сопровождения. Например, в объекте автомобиля класс Car может быть скрыт от остальной части программы. Преимуществами являются возможность повторного использования без учета конкретных деталей, на которые опирается объект, и более чистый код в целом.

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

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

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

3. Наследование
Когда в программе есть несколько классов со связанными свойствами, наследование может упростить ландшафт. В объектно-ориентированном программировании дочерние классы могут наследовать родительские классы и аналогичные функции. В качестве примера наследования рассмотрим, как класс Car может совместно использовать свойства с более крупной категорией, например с транспортными средствами.

«Автомобиль» в качестве родительского класса. «Автомобиль» и «Велосипед» — это дочерние классы, которые наследуют атрибуты родительского класса практически без усилий.

4. Полиморфизм
Полиморфизм — это состояние, при котором объект может принимать несколько форм. При этом полиморфизм может проявляться по-разному. Примеры полиморфизма включают:

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

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

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

Каковы преимущества объектно-ориентированного программирования?

Объектно-ориентированное программирование так выгодно из-за его пластичности. Способность рассматривать структуры кода как объекты в среде программирования позволяет программистам свободно формировать программы.

  • Модульность
  • Возможность повторного использования
  • Возможность подключения
  • Простота

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

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

В то же время масштабируемость имеет первостепенное значение для любого бизнеса в сфере разработки программного обеспечения. А этого редко можно добиться без объектно-ориентированного программирования.

5 лучших объектно-ориентированных языков программирования
Языки объектно-ориентированного программирования предоставляют разработчикам синтаксис и внутренние меры для использования ООП по своему желанию. Вот самые популярные и высокопроизводительные объектно-ориентированные языки программирования.

1. Питон
Python — это интерпретируемый язык программирования высокого уровня общего назначения. Разработчики выбирают Python для различных вариантов использования. Приложения Python варьируются от разработки игр до науки о данных и машинного обучения.

2. Java
Как язык программирования, основанный на классах, Java спроектирован так, чтобы иметь мало зависимостей; таким образом, разработчики Java могут рассчитывать на непрерывное повторное использование. Java известен как официальный язык программирования для Android-разработки .

3. Руби
Ruby выделяется среди других объектно-ориентированных языков программирования тем, что его цель — воспринимать практически все, что написано на языке, как объект. Юкихиро «Мац» Мацумото, разработчик Ruby, создал язык, когда почувствовал, что альтернативные языки ООП, такие как Python, не были по-настоящему объектно-ориентированными. Ruby on Rails — популярный веб-фреймворк, основанный на языке Ruby.

4. С++
C++, или C с классами, — это объектно-ориентированное расширение C. C — это классический язык программирования, который до сих пор занимает высокие позиции в индексе TIOBE. Тем не менее, его расширение C++ работает исключительно хорошо при работе со встроенными системами, такими как смарт-часы и медицинские машины.

5. С#
C# — это язык .NET Framework, продукт Microsoft, который помогает разработчикам создавать приложения. Как и C++, C# также является языком промежуточного программного обеспечения, который может тесно взаимодействовать с аппаратным обеспечением. C# в основном используется для разработки игр в Unity .

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

HR Блог для IT рекрутера в Телеграм

Хочешь всегда получать новые статьи, бесплатные материалы и полезные HR лайфхаки! Подписывайся на нас в Telegram! С нами подбор ит персонала становится проще 😉

Язык программирования Rust

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

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

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

Книга Приёмы объектно-ориентированного проектирования. Паттерны проектирования Erich Gamma, Richard Helm, Ralph Johnson, и John Vlissides (Addison-Wesley Professional, 1994), в просторечии называемая Книга банды четырёх, представляет собой сборник примеров объектно-ориентированного проектирования. В ней даётся следующее определение ООП:

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

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

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

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

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

pub struct AveragedCollection < list: Vec, average: f64, > 

Листинг 17-1: структура AveragedCollection содержит список целых чисел и их среднее арифметическое.

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

pub struct AveragedCollection  list: Vec, average: f64, > impl AveragedCollection < pub fn add(&mut self, value: i32) < self.list.push(value); self.update_average(); >pub fn remove(&mut self) -> Option  < 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; >> 

Листинг 17-2: Реализация публичных методов add , remove , и average для AveragedCollection

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

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

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

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

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

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

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

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

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

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

Полиморфизм

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

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

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

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

Что такое объектно-ориентированное программирование

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

Истоки ООП берут начало с 60-х годов XX века. Однако окончательное формирование основополагающих принципов и популяризацию идеи следует отнести к 80-м годам. Большой вклад внес Алан Кей.

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

В языке Python ООП играет ключевую роль. Даже программируя в рамках структурной парадигмы, вы все равно пользуетесь объектами и классами, пусть даже встроенными в язык, а не созданными лично вами.

Итак, что же такое объектно-ориентированное программирование? Судя по названию, ключевую роль здесь играют некие объекты, на которые ориентируется весь процесс разработки.

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

Программа состоит из объектов, которые действуют друг на друга с помощью методов

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

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

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

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

Основными понятиями, используемыми в ООП, являются класс, объект, наследование, инкапсуляция и полиморфизм. В языке Python класс равносилен понятию тип данных.

Понятия ООП: класс, объект, наследование, инкапсуляция, полиморфизм

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

Что такое класс или тип? Проведем аналогию с реальным миром. Если мы возьмем конкретный стол, то это объект, но не класс. А вот общее представление о столах, их назначении – это класс. Ему принадлежат все реальные объекты столов, какими бы они ни были. Класс столов дает общую характеристику всем столам в мире, он их обобщает.

Класс - это общее описание. Объект - это конкретная реализация.

То же самое с целыми числами в Python. Тип int – это класс целых чисел. Числа 5, 100134, -10 и т. д. – это конкретные объекты этого класса.

В языке программирования Python объекты принято называть также экземплярами. Это связано с тем, что в нем все классы сами являются объектами класса type . Точно также как все модули являются объектами класса module .

>>> a = 145 >>> b = [‘one’, ‘two’] >>> type(a) >>> type(b) >>> >>> type(int), type(list) (, ) >>> >>> import math >>> type(math)

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

Наследование, инкапсуляция, полиморфизм

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

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

Основное (но не единственное) преимущество, которое дает концепция наследования в программировании, – это вынос одинакового кода из разных классов в один родительский класс. Другими словами, наследование позволяет сводить на нет повторение кода в разных частях программы.

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

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

Отсутствие сокрытия данных в Python делает программирование на нем проще, но привносит ряд особенностей, связанных с пространствами имен.

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

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

Полиморфизм - одноименный метод в разных классах

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

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

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

Пример объектно-ориентированной программы на Python

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

В программе определены три класса. Класс A является родительским по отношению к B и C . Последние наследуют от A поле-переменную field1 и метод make_str , который потом переопределяют.

От каждого класса мы создаем по одному объекту и присваиваем их переменным a , b , c . Метод make_str выводит на экран значения полей объекта. У объектов разных классов разный набор полей, поэтому код метода отличается.

class A: field1 = 1 def make_str(self): print(self.field1) class B(A): field2 = 2 def make_str(self): print(self.field1, self.field2) class C(A): field3 = 3 def make_str(self): print(self.field1, self.field3) a = A() b = B() c = C() for i in (a, b, c): i.make_str()

Результат выполнения программы:

1 1 2 1 3

Практическая работа

Схема объектно-ориентированной программы

Рассмотрите схему. Подумайте над следующими вопросами:

  1. Какие фигуры на ней вы бы назвали классами, а какие – объектами? Что обозначают пунктирные линии?
  2. Может ли объект принадлежать множеству классов? Может ли у класса быть множество объектов?
  3. Звезды скорее обладают разными свойствами или разным поведением? Могут ли свойства оказывать влияние на поведение?
  4. Что могли бы обозначать стрелки?

Курс с примерами решений практических работ:
pdf-версия

X Скрыть Наверх

Объектно-ориентированное программирование на Python

Что такое объектно-ориентированное программирование: принципы, преимущества и недостатки

Существуют разные подходы к разработке программного обеспечения. Одним из наиболее популярных и эффективных является объектно-ориентированное программирование (ООП). С его помощью можно создавать, масштабировать и поддерживать довольно сложные проекты. Если ты хочешь стать разработчиком (Python, Java, Frontend или Fullstack), понимание основ ООП – это один из ключевых шагов на пути к успеху.

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

Что такое процедурное программирование и в чем его минусы

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

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

ООП лишено таких недостатков и позволяет вносить изменения в объект, который является ключевым элементом программы.

Что такое объектно-ориентированное программирование

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

Структура ООП состоит из объектов, классов, атрибутов и методов.

  • Объекты – это экземпляры классов, которые представляют реальные или абстрактные сущности.
  • Классы – шаблоны для создания объектов, определяющие их атрибуты и методы.
  • Атрибуты – это данные объекта, которые хранят его состояние.
  • Методы – функции, которые могут изменять состояние объекта или выполнять определенные действия.

Вот пример для понимания структуры объектно-ориентированного программирования:

Объект: тестировщик Антон

Атрибуты: зарплата и обязанности

Как видишь, атрибуты и методы здесь являются свойствами объекта. Такой подход позволяет упростить разработку комплексного ПО и писать хорошо структурированный код, с которым приятно работать.

Принципы объектно-ориентированного программирования

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

  • Инкапсуляция. Данные и методы, связанные с ними, хранятся внутри объекта. Это позволяет скрывать его внутреннюю реализацию и предоставлять только интерфейс, необходимый для взаимодействия. Так разработчик может создавать надежные и защищенные программы, предотвращая несанкционированный доступ. Кибербезопасность – это очень важно сейчас.
  • Наследование. В ООП можно создавать новые классы на основе уже существующих. Новый класс называется производным, а существующий – базовым или родительским. При наследовании производный класс получает все атрибуты и методы базового и может добавлять свои собственные. Наследование дает возможность повторно использовать код и создавать иерархии классов «от общего к частному» для реализации сложных схем. Это способствует повышению эффективности разработки и обеспечивает более логичную организацию кода. Не нужно постоянно переписывать одинаковые свойства для разных объектов, достаточно унаследовать их от одного «родителя».
  • Полиморфизм. Объекты разных классов могут иметь одинаковые методы, но реализовывать их разными способами. Программа работает со всеми объектами, используя общий интерфейс, что делает код более гибким и универсальным.
  • Абстракция. Вместо того чтобы детально описывать каждую часть системы, абстракция фокусируется только на самом важном. Она позволяет разработчикам скрыть сложность реализации и сосредоточиться на ключевых аспектах объекта.

ООП кажется идеальным подходом. Но так ли это на самом деле? Читай дальше, чтобы узнать ответ.

Преимущества и недостатки объектно-ориентированного программирования

Плюсы объектно-ориентированного программирования являются одной из причин его широкого применения в разных областях разработки. Вот некоторые из них:

  • Модульность и повторное использование кода. ООП позволяет разделить программу на небольшие и понятные части, которые отвечают за определенную функциональность. Модули, классы и объекты могут быть использованы повторно, что упрощает разработку, отладку и поддержку ПО.
  • Гибкость и масштабируемость. ООП делает программу более гибкой и расширяемой, позволяя добавлять новые классы и методы без необходимости переписывать весь код. Это обеспечивает возможность адаптации софта к изменяющимся требованиям.
  • Простота сопровождения. Каждый объект имеет свою собственную функциональность и данные, что упрощает поиск и исправление ошибок. Код становится понятным, поэтому тестировщикам и программистам с ним проще работать.
  • Безопасность. Софт с инкапсулированным кодом сложнее взломать.
  • Улучшение производительности. Разработчики пишут оптимизированный и эффективный код, что может привести к повышению производительности программы.
  • Легкая интеграция. ООП позволяет быстро интегрировать различные компоненты программы, создавая объекты, которые взаимодействуют друг с другом. Это упрощает разработку сложных систем.

Несмотря на множество преимуществ, объектно-ориентированное программирование имеет некоторые недостатки, которые следует учитывать при разработке ПО:

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

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

Примеры использования принципов ООП

Принципы объектно-ориентированного программирования широко применяются в разных областях разработки. Вот несколько примеров из реальной жизни:

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

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

Медицина. ООП применяется для разработки медицинских информационных систем, которые хранят и обрабатывают данные. Классы и объекты представляют пациентов, врачей, лекарства и т.д. Инкапсуляция обеспечивает безопасное хранение и доступ к ним

Какие языки программирования поддерживают ООП

Существует множество языков программирования, которые поддерживают эту парадигму. Вот несколько популярных примеров:

  • Java использует классы и объекты для организации кода.
  • C++ предоставляет все основные возможности ООП.
  • Python – высокоуровневый язык, который подходит как для процедурного, так и для объектно-ориентированного программирования.
  • C# широко применяется для разработки приложений на платформе .NET и тоже поддерживает ООП.
  • Ruby – это динамический, интерпретируемый язык, который активно использует принципы объектно-ориентированного программирования.
  • PHP обладает всеми необходимыми инструментами для создания классов, объектов, наследования, инкапсуляции и полиморфизма.

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

Если ты хочешь стать программистом, но пока не определился с направлением, запишись на один бесплатных марафонов от GoIT. Попробуй себя в роли Python-разработчика, Java-программиста или тестировщика. Узнай больше про эти профессии, создай первые проекты и проверь свои силы. Возможно, тебе понравится одна из них.

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

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *