Разное

Объектно ориентированный: Что такое ООП? Объектно-ориентированное программирование

Содержание

Объектно-ориентированное программирование. Классы и объекты

Сегодня мы поговорим об объектно-ориентированном программировании и о его применении в python.

Объектно-ориентированное программирование (ООП) — парадигма программирования, в которой основными концепциями являются понятия объектов и классов.

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

Python соответствует принципам объектно-ориентированного программирования. В python всё является объектами — и строки, и списки, и словари, и всё остальное.

Но возможности ООП в python этим не ограничены. Программист может написать свой тип данных (класс), определить в нём свои методы.

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

Приступим теперь собственно к написанию своих классов на python. Попробуем определить собственный класс:

>>> # Пример простейшего класса, который ничего не делает
... class A:
...     pass

Теперь мы можем создать несколько экземпляров этого класса:

>>> a = A()
>>> b = A()
>>> a.arg = 1  # у экземпляра a появился атрибут arg, равный 1
>>> b.arg = 2  # а у экземпляра b - атрибут arg, равный 2
>>> print(a.arg)
1
>>> print(b.arg)
2
>>> c = A()
>>> print(c.arg)  # а у этого экземпляра нет arg
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'arg'

Классу возможно задать собственные методы:

>>> class A:
...     def g(self): # self - обязательный аргумент, содержащий в себе экземпляр
...                  # класса, передающийся при вызове метода,
...                  # поэтому этот аргумент должен присутствовать
...                  # во всех методах класса. 
...         return 'hello world'
...
>>> a = A()
>>> a.g()
'hello world'

И напоследок еще один пример:

>>> class B:
...     arg = 'Python' # Все экземпляры этого класса будут иметь атрибут arg,
...                    # равный "Python"
...                    # Но впоследствии мы его можем изменить
...     def g(self):
...         return self.arg
...
>>> b = B()
>>> b.g()
'Python'
>>> B.g(b)
'Python'
>>> b.arg = 'spam'
>>> b.g()
'spam'

НОУ ИНТУИТ | Введение в теорию программирования. Объектно-ориентированный подход

Автор: Сергей Зыков | Национальный исследовательский ядерный университет «МИФИ»

Форма обучения:

дистанционная

Стоимость самостоятельного обучения:

бесплатно

Доступ:

свободный

Документ об окончании:

Уровень:

Для всех

Длительность:

10:50:00

Выпускников:

348

Качество курса:

4. 16 | 3.86


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


Курс проиллюстрирован примерами, связывающими фундаментальные понятия теории с особенностями программирования на языке C# (типизация, наследование, инкапсуляция, полиморфизм, динамическое связывание и др.) и языке SML («ленивые» вычисления, расширенный полиморфизм, выводимость типов и т.д.). Базовые аспекты профессионального программирования излагаются в сравнении языков C# и SML на единой платформе Microsoft .NET.Сравнительное изучение языков программирования «нового поколения» SML и C# дает возможность более глубоко проникнуть в суть процесса создания программных систем.

Теги: . net, common type system, CTS, greeting, ilist, isa, objective-c, SML, библиотеки, веб-сервисы, виртуальный метод, вычисления, интерфейсы, компиляторы, компоненты, курсы, несоответствие типа, объектно-ориентированное программирование, приложения, программирование, производный класс, сервисы, система типизации, среда вычислений, теория, элементы


Предварительные курсы

 

2 часа 30 минут


Вступительная лекция

Обзор истории развития научных направлений, сформировавших теоретическое основание курса.


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

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


Основные понятия языка
программирования C#

В лекции обсуждаются вопросы, относящиеся к понятийному аппарату,
истории развития, выразительным возможностям синтаксиса и особенностям реализации языка
C# в сравнении с другими объектно-ориентированными языками программирования.


Семантика основных конструкций языка программирования C#

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


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

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


Объекты и классы

Цель: ознакомление с основой объектного подхода в языке C#, созданием объектов, классов и механизмом наследования.


Теория типов и типизация в .NET

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


Концепция наследования и ее реализация в языке C#

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


Концепция инкапсуляции и
ее реализация в языке C#

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


Концепция полиморфизма
и ее реализация в языке C#

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


Полиморфные методы

Цель: Ознакомление с особенностями создания и применения полиморфных методов в языке программирования C#.


Расширенные возможности
полиморфизма в языке C#

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


Событийно управляемое
программирование в .NET

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


Компонентное программирование в .NET

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

Объектно-ориентированный стиль

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

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

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

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

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

Класс — это тип объекта, а объект — это экземпляр (переменная) определенного класса.

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

Editl.Text := 'NewData';

лрисваивает значение ‘NewData1 свойству Text поля ввода Editl (элементы управления являются объектами). Оператор разыменования при этом не используется.

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

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

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

Полиморфизм (дословно — способность проявляться во многих формах) означает, что программа может обрабатывать объект по-разному в зависимости от его класса. Это достигается путем переопределения методов родительского класса в его дочерних классах. Пусть, например, класс Shape (Фигура) является базовым для классов Circle (Круг), Rectangle (Прямоугольник) и Triangle (Треугольник). Принцип полиморфизма позволяет определить для всех этих классов метод Area, вычисляющий площадь фигуры. Для объекта каждого дочернего класса площадь вычисляется по-разному, однако поскольку метод Area переопределяется (т.е. применяется метод соответствующего дочернего класса), программист может вызывать метод Area, не уточняя вид фигуры. При этом до момента вызова метода в программе вид фигуры вообще может быть неизвестен, и ее характеристики будут определены только в момент вызова.

⇐Структурный стиль программирования || Оглавление || Реализация принципов ООП в Delphi⇒

Объектно-ориентированный Python — Введение — CoderLessons.com

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

В этой главе рассказывается об особенностях языка программирования Python, который делает его объектно-ориентированным языком программирования.

Схема классификации языкового программирования

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

Языковые классы категории Langauages
Парадигма программирования процедурный C, C ++, C #, Objective-C, Java, Go
Scripting CoffeeScript, JavaScript, Python, Perl, Php, Ruby
функциональная Clojure, Eralang, Haskell, Scala
Класс компиляции статический C, C ++, C #, Objective-C, Java, Go, Haskell, Scala
динамический CoffeeScript, JavaScript, Python, Perl, Php, Ruby, Clojure, Erlang
Тип Класс сильный C #, Java, Go, Python, Ruby, Clojure, Erlang, Haskell, Scala
слабый C, C ++, C #, Objective-C, CoffeeScript, JavaScript, Perl, Php
Класс памяти Удалось другие
Неуправляемый C, C ++, C #, Objective-C

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

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

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

Объектно-ориентированный анализ (OOA) — это процесс изучения проблемы, системы или задачи и определения объектов и взаимодействий между ними.

Почему стоит выбрать объектно-ориентированное программирование?

Python был разработан с объектно-ориентированным подходом. ООП предлагает следующие преимущества —

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

  • Облегчает простое обслуживание и модификацию существующего кода.

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

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

  • Придает код многократного использования

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

Облегчает простое обслуживание и модификацию существующего кода.

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

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

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

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

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

В таблице на следующем рисунке показаны основные различия между подходами POP и OOP.

Разница между процедурно-ориентированным программированием (POP) и Объектно-ориентированное программирование (ООП).

Процедурно-ориентированное программирование Объектно-ориентированное программирование
На основе В Pop все внимание сосредоточено на данных и функциях. Упс основан на сценарии реального мира. Вся программа делится на небольшие части, называемые объектом
Повторное использование Ограниченное повторное использование кода Повторное использование кода
Подход Нисходящий подход Объектно-ориентированный дизайн
Спецификаторы доступа Не любой Государственный, частный и охраняемый
Движение данных Данные могут свободно перемещаться от функций к функциям в системе В Oops данные могут перемещаться и взаимодействовать друг с другом через функции-члены
Доступ к данным В поп-музыке большинство функций использует глобальные данные для совместного использования, к которым можно свободно обращаться от функции к функции в системе В Oops данные не могут свободно перемещаться от метода к методу, они могут храниться в публичном или частном порядке, чтобы мы могли контролировать доступ к данным.
Скрытие данных В поп, такой специфический способ скрыть данные, так немного менее безопасный Это обеспечивает сокрытие данных, гораздо более безопасный
перегрузка Невозможно Функции и перегрузка операторов
Пример-Языки C, VB, Фортран, Паскаль C ++, Python, Java, C #
абстракция Использует абстракцию на уровне процедуры Использует абстракцию на уровне класса и объекта

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

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

Давайте кратко разберем каждый из столпов объектно-ориентированного программирования —

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

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

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

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

абстракция

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

Полиморфизм

Полиморфизм означает много форм. То есть вещь или действие присутствует в разных формах или способах. Один хороший пример полиморфизма — перегрузка конструктора в классах.

Объектно-ориентированный Питон

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

Модули против Классов и Объектов

Модули похожи на «Словари»

При работе с модулями обратите внимание на следующие моменты:

  • Модуль Python — это пакет для инкапсуляции многократно используемого кода.

  • Модули находятся в папке с файлом __init__.py .

  • Модули содержат функции и классы.

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

Модуль Python — это пакет для инкапсуляции многократно используемого кода.

Модули находятся в папке с файлом __init__.py .

Модули содержат функции и классы.

Модули импортируются с использованием ключевого слова import .

Напомним, что словарь является парой ключ-значение . Это означает, что если у вас есть словарь с ключевым EmployeID, и вы хотите получить его, то вам придется использовать следующие строки кода:

employee = {“EmployeID”: “Employee Unique Identity!”}
print (employee [‘EmployeID])

Вам придется работать над модулями с помощью следующего процесса —

  • Модуль — это файл Python с некоторыми функциями или переменными.

  • Импортируйте нужный вам файл.

  • Теперь вы можете получить доступ к функциям или переменным в этом модуле с помощью «.» (точка) Оператор.

Модуль — это файл Python с некоторыми функциями или переменными.

Импортируйте нужный вам файл.

Теперь вы можете получить доступ к функциям или переменным в этом модуле с помощью «.» (точка) Оператор.

Рассмотрим модуль с именем employee.py, в котором есть функция employee . Код функции приведен ниже —

# this goes in employee.py
def EmployeID():
   print (“Employee Unique Identity!”)

Теперь импортируйте модуль и затем получите доступ к функции EmployeID

import employee
employee. EmployeID()

Вы можете вставить переменную с именем Age , как показано на рисунке —

def EmployeID():
   print (“Employee Unique Identity!”)
# just a variable
Age = “Employee age is **”

Теперь, доступ к этой переменной следующим образом —

import employee
employee.EmployeID()
print(employee.Age)

Теперь давайте сравним это со словарем —

Employee[‘EmployeID’] # get EmployeID from employee
Employee.employeID() # get employeID from the module
Employee. Age # get access to variable

Обратите внимание, что в Python есть общий шаблон —

Возьмите ключ = значение стиля контейнера

Получите что-нибудь из этого по имени ключа

При сравнении модуля со словарем оба они похожи, за исключением следующего:

  • В случае словаря ключ является строкой, а синтаксис — [ключ].

  • В случае модуля ключ является идентификатором, а синтаксис — .key.

В случае словаря ключ является строкой, а синтаксис — [ключ].

В случае модуля ключ является идентификатором, а синтаксис — .key.

Классы как Модули

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

Если вам нужно создать класс, похожий на модуль employee, вы можете сделать это, используя следующий код:

class employee(object):
   def __init__(self):
      self.  Age = “Employee Age is ##”
   def EmployeID(self):
      print (“This is just employee unique identity”)

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

Объекты похожи на мини-импорт

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

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

this_obj = employee() # Instantiatethis_obj.EmployeID() # get EmployeId from the class
print(this_obj.Age) # get variable Age

Вы можете сделать это любым из следующих трех способов —

Объектно-ориентированная парадигма | Персональный блог

Немного истории о возникновении парадигмы

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

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

В 1970 году Алан Кей и его исследовательская группа в Xerox PARK создали персональный компьютер под названием Dynabook и первый чистый объектно-ориентированный язык программирования (OOPL) – Smalltalk, для программирования Dynabook.

В 1980-х Грэди Буч опубликовал статью под названием «Объектно-ориентированный дизайн», в которой в основном представлен дизайн для языка программирования Ada. В последующих изданиях он расширил свои идеи до полного метода объектно-ориентированного проектирования.

В 1990-х годах Коад включил идеи поведения в объектно-ориентированные методы.

Другими значительными нововведениями были Методы объектного моделирования (OMT) Джеймса Румбо и Объектно-ориентированная программная инженерия (OOSE) Ивара Якобсона.

Объектно-ориентированный анализ

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

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

Грэди Буч определил OOA как «Объектно-ориентированный анализ – это метод анализа, который исследует требования с точки зрения классов и объектов, найденных в словаре проблемной области».

Основными задачами в объектно-ориентированном анализе (ООА) являются:

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

Распространенными моделями, используемыми в OOA, являются сценарии использования и объектные модели.

Объектно-ориентированный дизайн

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

Детали реализации обычно включают в себя:

  • Реструктуризация данных класса (при необходимости)
  • Реализация методов, внутренних структур данных и алгоритмов
  • Осуществление контроля
  • Реализация ассоциаций

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

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

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

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

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

Некоторыми примерами объектно-ориентированных языков программирования являются C++, Java, Smalltalk, Delphi, C#, Perl, Python, Ruby и PHP.

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

Поделиться ссылкой:

Понравилось это:

Нравится Загрузка…

Похожие публикации

Иллюстрированный самоучитель по введению в экспертные системы › Объектно-ориентированное программирование › Объектно-ориентированный анализ и конструирование экспертных систем [страница — 106] | Самоучители по программированию

Объектно-ориентированный анализ и конструирование экспертных систем

Философия и технология объектно-ориентированного программирования могут весьма пригодиться проектировщику экспертных систем.

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

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

  • Объекты в основном являются средствами реализации вычислений.
  • Идея наследования поведения влечет за собой появление множества проблем при ее реализации, как мы видели это на примере с классами окон. Некоторые из появившихся в последнее время объектно-ориентированных схем допускают наследование только интерфейсов.
  • Определенные сложности возникают с реализацией наследования при использовании новых технологий многокомпонентных объектов, таких как СОМ (см. [Chappell, 1996]).

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

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

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

Объектно-ориентированное программирование (С++)|ИТММ ННГУ

Кафедра информатики и автоматизации научных исследований

Специальность: Прикладная информатика

Преподаватель: Филимонов А.В.

Целями освоения дисциплины (модуля) «Объектно-ориентированное программирование (С++)»  являются получение знаний и практических навыков программирования на языке С++ в рамках объектно-ориентированного программирования.

В курсе приводятся основные аспекты объектно-ориентированного программирования (ООП), даются основы языка С++, как средства реализации объектно-ориентированной парадигмы. Даются основные понятия и конструкции языка, методы реализации базовых операций. Рассматривается способ реализации объектно-ориентированной парадигмы средствами языка С++.

В результате освоения дисциплины обучающийся должен:

Знать: основы терминологии, конструкции (синтаксис, операции, работа с указателями, базовые библиотеки) языка С++, базовые принципы применения языка.

Уметь: Писать программы на языке С++ с использованием одного из компиляторов и одного из визуальных средств разработки.

Владеть: основными принципами компиляции, выполнения и отладки программ на С++ на основе одной из визуальных сред разработки.

Содержание

1. БАЗОВЫЕ ЗНАНИЯ О С++

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

Имена, переменные и константы. Правила именования переменных и функций языка, правила записи констант. Понятие ключевого или зарезервированного слова, список ключевых слов Си++.

Операции и выражения. Правила формирования и вычисления выражений в языке Си++. Все операции языка.

Операторы. Описываются все операторы управления, имеющиеся в языке Си++, даются примеры их использования.

Функции. Функции – это основные единицы построения программ при процедурном программировании на языке Си++. Правила их записи, вызова и передачи параметров.

Встроенные типы данных. Рассматриваются все встроенные типы языка Си++: целые числа разной разрядности, вещественные числа, логические величины, перечисляемые значения, символы и их кодировка.

2. КЛАССЫ И ОБЪЕКТЫ.

Классы и объекты. Способы описания классов. Создание объектов. Обращение к атрибутам и методам объектов.

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

Распределение памяти. Проблемы при явном распределении памяти в Си++, способы их решения. Ссылки и указатели. Распределение памяти под переменные, управление памятью с помощью переопределения операторов new и delete.

Производные классы, наследование. Наследование, виды наследования. Виртуальные методы. Абстрактные классы. Множественное наследование.

Контроль доступа к объекту. Рассматриваются возможности контроля доступа к атрибутам и методам объекта, контроль по чтению и по записи.

Классы – конструкторы и деструкторы. Конструкторы и деструкторы классов. Возможности инициализации объектов. Копирующий конструктор. Операции new и delete.

Дополнительные возможности классов. Рассматриваются дополнительные возможности при определении классов, включая переопределение операций, определение методов inline и задание собственных преобразований типа.

3. КОМПОНОВКА ПРОГРАММ, ПРЕПРОЦЕССОР

Компоновка программ, препроцессор. Компоновка программ, возможности, позволяющие писать большие программы.

Определение, время жизни и области видимости переменных в больших программах
Возможности построения больших программ, использование общих данных. Определение контекста, оператор namespace.

4. ОБРАБОТКА ОШИБОК, ШАБЛОНЫ

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

Ввод-вывод. Потоки. Манипуляторы и форматирование ввода-вывода. Строковые потоки. Ввод-вывод файлов.

Шаблоны. Понятие шаблона. Функции-шаблоны. Шаблоны классов. Примеры использования.

Лабораторный практикум

  1. Простейшая программа на С++. Среда разработки Visual Studio. Ввод программы, компиляция, выполнение.
  2. Арифметические операции и математические функции языка С
  3. Битовые операции
  4. Работа с матрицами. Структуры и массивы структур
  5. Указатели, массивы, символьные строки и функции
  6. Классы, объекты и их ассоциации.
  7. Наследование и ограничение видимости
  8. Обработка ошибок и шаблоны

Литература

а) основная литература:

  1. Г. Шилдт — C++. Руководство для начинающих
  2. Г. Шилдт — Самоучитель C++

б) дополнительная литература:

  1. Роберт Седжвик — Фундаментальные алгоритмы на C++. Части 1-4. Анализ. Структуры данных. Сортировка. Поиск

Отчетность

Объектно-ориентированный JavaScript для начинающих — Изучите веб-разработку

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

Предварительные требования: Базовая компьютерная грамотность, базовое понимание HTML и CSS, знакомство с основами JavaScript (см. Первые шаги и Строительные блоки) и основами OOJS (см. Введение в объекты).
Цель: Чтобы понять основную теорию объектно-ориентированного программирования, как это связано с JavaScript («все является объектом») и как создавать конструкторы и экземпляры объектов.

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

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

Определение шаблона объекта

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

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

Создание реальных объектов

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

Когда экземпляр объекта создается из класса, для его создания запускается функция конструктора класса . Этот процесс создания экземпляра объекта из класса называется экземпляром — экземпляр объекта создан экземпляром из класса.

Классы специалистов

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

Это действительно полезно — учителя и ученики имеют много общих черт, таких как имя, пол и возраст, поэтому удобно определять эти особенности только один раз.Вы также можете определить одну и ту же функцию отдельно в разных классах, поскольку каждое определение этой функции будет находиться в другом пространстве имен. Например, приветствие ученика может иметь форму «Йо, я [имя]» (например, Йо, я Сэм ), тогда как учитель может использовать что-то более формальное, например «Привет, меня зовут [Prefix] [lastName], и ​​я преподаю [Subject] ». (например, Здравствуйте, меня зовут мистер Гриффитс, я преподаю химию ).

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

Теперь вы можете создавать экземпляры объектов из дочерних классов. Например:

В оставшейся части статьи мы начнем смотреть, как теорию ООП можно применить на практике в JavaScript.

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

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

Простой пример

  1. Давайте начнем с рассмотрения того, как вы могли бы определить человека с нормальной функцией. Добавьте эту функцию в элемент сценария :
      function createNewPerson (name) {
      const obj = {};
      obj.name = имя;
      объектwelcome = function () {
        alert ('Привет! Я' + имя объекта + '. ');
      };
      return obj;
    }  
  2. Теперь вы можете создать нового человека, вызвав эту функцию - попробуйте следующие строки в консоли JavaScript вашего браузера:
      const salva = createNewPerson ('Salva');
    salva.name;
    salva.greeting ();  

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

  3. Замените вашу предыдущую функцию следующей:
      function Person (имя) {
      это.name = name;
      this.greeting = function () {
        alert ('Привет! Я' + this.name + '.');
      };
    }  

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

Примечание : Имя функции конструктора обычно начинается с заглавной буквы - это соглашение используется для упрощения распознавания функций конструктора в коде.

Так как же вызвать конструктор для создания некоторых объектов?

  1. Добавьте следующие строки под предыдущим добавлением кода:
      let person1 = new Person («Боб»);
    let person2 = новый человек ('Сара');  
  2. Сохраните свой код, перезагрузите его в браузере и попробуйте ввести следующие строки в консоль JS:
      человек1.имя
    person1.greeting ()
    person2.name
    person2. greeting ()  

Круто! Теперь вы можете видеть, что у нас есть два новых объекта на странице, каждый из которых хранится в другом пространстве имен - когда вы обращаетесь к их свойствам и методам, вы должны начинать вызовы с person1 или person2 ; функциональность, содержащаяся внутри, аккуратно упакована, поэтому она не будет конфликтовать с другими функциями. Однако они имеют те же свойства name, и welcome () .Обратите внимание, что они используют собственное имя , значение , которое было присвоено им при создании; это одна из причин, почему очень важно использовать и , поэтому каждый из них использует свое собственное значение, а не какое-либо другое значение.

Давайте еще раз посмотрим на вызовы конструктора:

  let person1 = new Person («Боб»);
let person2 = новый человек ('Сара');  

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

  function Person (имя) {
  this.name = имя;
  this.greeting = function () {
    alert ('Привет! Я' + this.name + '.');
  };
}  

После создания новых объектов переменные person1 и person2 содержат следующие объекты:

  {
  имя: 'Боб',
  приветствие: function () {
    alert ('Привет! Я' + this.name + '.');
  }
}

{
  имя: 'Сара',
  приветствие: function () {
    alert ('Привет! Я' + это.имя + '.');
  }
}  

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

Создание готового конструктора

Пример, который мы рассмотрели выше, был всего лишь простым примером для начала. Давайте теперь приступим к созданию нашей последней функции-конструктора Person () .

  1. Удалите код, который вы вставили до сих пор, и добавьте в этот конструктор замены - это в принципе то же самое, что и простой пример, только с немного большей сложностью:
      функция Человек (имя, фамилия, возраст, пол, интересы) {
      это.name = {
         первое: первое,
         последний: последний
      };
      this.age = возраст;
      this.gender = пол;
      this.interests = интересы;
      this.bio = function () {
        alert (this.name.first + '' + this.name.last + '' + this.age + 'лет. Ему нравится' + this.interests [0] + 'и' + this.interests [1] + '.');
      };
      this.greeting = function () {
        alert ('Привет! Я' + this.name.first + '.');
      };
    }  
  2. Теперь добавьте следующую строку под ним, чтобы создать из него экземпляр объекта:
      let person1 = new Person («Боб», «Смит», 32, «мужчина», [«музыка», «катание на лыжах»]);  

Теперь вы можете видеть, что у вас есть доступ к свойствам и методам, как мы делали раньше - попробуйте их в своей консоли JS:

  человек1 ["возраст"]
person1. интересы [1]
person1.bio ()
  

Дальнейшие упражнения

Для начала попробуйте добавить еще пару собственных строк создания объекта и попробуйте получить и установить члены полученных экземпляров объекта.

Кроме того, есть несколько проблем с нашим методом bio () - вывод всегда включает местоимение «Он», даже если ваш человек - женщина, или какой-либо другой предпочтительный гендерный класс. И биография включает только два интереса, даже если больше перечислено в массиве интересов .Можете придумать, как исправить это в определении класса (конструкторе)? Вы можете поместить в конструктор любой код, который вам нравится (возможно, вам понадобится несколько условных выражений и цикл). Подумайте о том, как предложения должны быть по-разному структурированы в зависимости от пола и в зависимости от того, составляет ли количество перечисленных интересов 1, 2 или более 2.

До сих пор мы видели два разных способа создания экземпляра объекта - объявление литерала объекта и использование функции-конструктора (см. Выше).

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

Конструктор Object ()

Прежде всего, вы можете использовать конструктор Object () для создания нового объекта. Да, даже у универсальных объектов есть конструктор, который генерирует пустой объект.

  1. Попробуйте ввести это в консоль JavaScript вашего браузера:
      let person1 = new Object ();  
  2. Сохраняет пустой объект в переменной person1 . Затем вы можете добавить свойства и методы к этому объекту, используя точечную или квадратную нотацию по желанию; попробуйте эти примеры на своей консоли:
      человек1.name = 'Крис';
    person1 ['age'] = 38;
    person1.greeting = function () {
      alert ('Привет! Я' + this.name + '.');
    };  
  3. Вы также можете передать литерал объекта в конструктор Object () в качестве параметра, чтобы предварительно заполнить его свойствами / методами. Попробуйте это в своей консоли JS:
      let person1 = new Object ({
      имя: 'Крис',
      возраст: 38,
      приветствие: function () {
        alert ('Привет! Я' + this.name + '.');
      }
    });  

Использование метода create ()

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

Однако некоторые люди предпочитают создавать экземпляры объектов без предварительного создания конструкторов, особенно если они создают только несколько экземпляров объекта. В JavaScript есть встроенный метод create () , который позволяет вам это делать. С его помощью вы можете создать новый объект, используя существующий объект в качестве прототипа вновь созданного объекта.

  1. Завершив упражнение из предыдущих разделов, загруженное в браузер, попробуйте это в консоли JavaScript:
      let person2 = Объект. создать (person1);  
  2. Теперь попробуйте следующее:
      person2.name;
    person2.greeting ();  

Вы увидите, что person2 было создано на основе person1 в качестве своего прототипа - он имеет те же свойства и доступные ему методы.

Одно из ограничений create () заключается в том, что IE8 не поддерживает его. Так что конструкторы могут быть более эффективными, если вы хотите поддерживать старые браузеры.

Мы рассмотрим эффекты create () более подробно позже.

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

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

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

В следующей статье мы рассмотрим прототипы объектов JavaScript.

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

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

Связано: 15 хорошо оплачиваемых вакансий в области компьютерных наук

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

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

Этот стиль программирования широко используется в широко используемых языках программирования, таких как Java, C ++ и PHP. Эти языки помогают упростить структуру и организацию программного обеспечения. Программисты часто используют ООП, когда им нужно создавать сложные программы.

Связано: Написание технического резюме: советы и примеры

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

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

  • Инкапсуляция
  • Абстракция
  • Наследование
  • Полиморфизм

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

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

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

Абстракция

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

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

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

Вместо переопределения свойств и методов для каждого типа элемента HTML вы можете определить их один раз в универсальном объекте. Называя этот объект чем-то вроде «HTMLElement», другие объекты унаследуют его свойства и методы, так что вы сможете сократить ненужный код.

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

Полиморфизм

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

Связано: Компьютерные навыки: определения и примеры

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

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

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

Пример инкапсуляции

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

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

Пример абстракции

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

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

Пример наследования

Рассмотрим два класса. Один из них - это суперкласс (родительский), а подкласс (дочерний) наследует свойства родительского класса и изменяет его поведение. Программисты, применяющие технику наследования, выстраивают эти классы в иерархию отношений типа «это тип».

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

Пример полиморфизма

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

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

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

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

В этой статье будут подробно рассмотрены следующие аспекты:

Приступим.

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

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

Теперь, чтобы получить более ясное представление о том, почему мы используем oops вместо pop, я перечислил ниже различия.

Разница между объектно-ориентированным и процедурно-ориентированным программированием

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

Процедурно-ориентированное

0

4

4

Это восходящий подход

Это нисходящий подход

Программа разделена на объекты

Программа разделена на функции

Использует Доступ модификаторы

'public', private ', protected'

Не использует Модификаторы доступа

Это более безопасно

Это менее безопасно

Объект может свободно перемещаться внутри функций-членов

Данные могут свободно перемещаться из функции n для работы в программах

Он поддерживает наследование

Он не поддерживает наследование

Это все о различиях, продвигаясь вперед, давайте разберемся с Python OOP Conceots.

Что такое концепции ООП Python?

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

Вот и все о различиях, забегая вперед, давайте разберемся с классами и объектами.

Что такое классы и объекты?

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

Что ж, он логически группирует данные таким образом, что повторное использование кода становится простым. Я могу привести вам пример из реальной жизни: представьте, что офисный «сотрудник» представляет собой класс, а все атрибуты, связанные с ним, такие как «emp_name», «emp_age», «emp_salary», «emp_id», являются объектами в Python. Давайте посмотрим с точки зрения кодирования, как создать экземпляр класса и объекта.

Класс определяется ключевым словом «Класс».
Пример:

class class1 (): // class 1 - это имя класса
 

Примечание. Python не чувствителен к регистру.

Объекты:

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

Синтаксис: obj = class1 ()

Здесь obj - «объект» класса class1.

Создание объекта и класса в python:

Пример:

 class employee ():
    def __init __ (self, name, age, id, salary): // создание функции
        себя.name = name // self - это экземпляр класса
        self.age = возраст
        self.salary = зарплата
        self.id = id

emp1 = employee ("harshit", 22,1000,1234) // создание объектов
emp2 = сотрудник ("арджун", 23,2000,2234)
print (emp1 .__ dict __) // Распечатывает словарь
 

Объяснение: 'emp1' и 'emp2' - это объекты, экземпляры которых создаются для класса «employee». Здесь слово (__dict__) представляет собой «словарь», который печатает все значения объекта «emp1» напротив заданный параметр (имя, возраст, зарплата).(__init__) действует как конструктор, который вызывается всякий раз, когда создается объект.

Надеюсь, теперь вы, ребята, не столкнетесь с какими-либо проблемами при работе с «классами» и «объектами» в будущем.

Итак, позвольте мне познакомить вас с методологиями объектно-ориентированного программирования:

Методологии объектно-ориентированного программирования:

Методологии объектно-ориентированного программирования имеют дело со следующими концепциями.

  • Наследование
  • Полиморфизм
  • Инкапсуляция
  • Абстракция

Давайте подробно разберемся с первой концепцией наследования.

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

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

Давайте разберемся с каждой из подтем подробно.

Одиночное наследование:

Одноуровневое наследование позволяет производному классу наследовать характеристики от единственного родительского класса.

Пример:

 class employee1 (): // Это родительский класс
def __init __ (я, имя, возраст, зарплата):
self.name = имя
self.age = возраст
self.salary = зарплата

class childemployee (employee1): // Это дочерний класс
def __init __ (я, имя, возраст, зарплата, идентификатор):
self.name = имя
self.age = возраст
self.salary = зарплата
себя.id = id
emp1 = employee1 ('суровый', 22,1000)

печать (emp1.age)
 

Выходные данные : 22

Объяснение:

  • Я беру родительский класс и создал конструктор (__init__), сам класс инициализирует атрибуты параметрами ('name', 'age' и 'salary ').

  • Создан дочерний класс childemployee, который наследует свойства от родительского класса, и, наконец, созданы экземпляры объектов emp1 и emp2 в соответствии с параметрами.

  • Наконец, я напечатал возраст emp1. Ну, вы можете делать много чего, например, распечатать весь словарь, или имя, или зарплату.

Многоуровневое наследование:

Многоуровневое наследование позволяет производному классу наследовать свойства от непосредственного родительского класса, который, в свою очередь, наследует свойства от своего родительского класса.

Пример:

 class employee (): // Суперкласс
def __init __ (я, имя, возраст, зарплата):
себя.name = имя
self.age = возраст
self.salary = зарплата
class childemployee1 (employee): // Первый дочерний класс
def __init __ (я, имя, возраст, зарплата):
self.name = имя
self.age = возраст
self.salary = зарплата

class childemployee2 (childemployee1): // Второй дочерний класс
def __init __ (я, имя, возраст, зарплата):
self.name = имя
self.age = возраст
self.salary = зарплата
emp1 = сотрудник ('суровый', 22,1000)
emp2 = childemployee1 ('арджун', 23,2000)

печать (emp1.age)
печать (emp2.age)
 

Вывод: 22,23

Объяснение:

  • Это ясно объяснено в коде, написанном выше. Здесь я определил суперкласс как сотрудник, а дочерний класс как childemployee1.Теперь childemployee1 действует как родитель для childemployee2.

  • Я создал два объекта emp1 и emp2, где я передаю параметры «name», «age», «salary» для emp1 из суперкласса «employee» и «name», «age,« зарплата ». »И« id »из родительского класса« childemployee1 »

Иерархическое наследование:

Наследование на иерархическом уровне позволяет более чем одному производному классу наследовать свойства родительского класса.

Пример:

 класс сотрудника ():
def __init __ (я, имя, возраст, зарплата): // Иерархическое наследование
self.name = имя
self.age = возраст
self.salary = зарплата

класс childemployee1 (сотрудник):
def __init __ (я, имя, возраст, зарплата):
self.name = имя
self.age = возраст
self.salary = зарплата

класс childemployee2 (сотрудник):
def __init __ (я, имя, возраст, зарплата):
self.name = имя
self.age = возраст
self.salary = зарплата
emp1 = сотрудник ('суровый', 22,1000)
emp2 = сотрудник ('арджун', 23,2000)

печать (emp1.возраст)
печать (emp2.age)
 

Вывод: 22,23

Объяснение:

  • В приведенном выше примере вы можете ясно видеть, что существует два дочерних класса «childemployee1» и «childemployee2». Они наследуют функциональные возможности от общего родительского класса «сотрудник».

  • Объекты emp1 и emp2 создаются по параметрам «имя», «возраст», «зарплата».

Множественное наследование:

Множественное наследование позволяет одному производному классу наследовать свойства более чем одного базового класса.

Пример:

 class employee1 (): // Родительский класс
    def __init __ (я, имя, возраст, зарплата):
        self.name = имя
        self.age = возраст
        self.salary = зарплата

class employee2 (): // Родительский класс
    def __init __ (я, имя, возраст, зарплата, идентификатор):
     self.name = имя
     self.age = возраст
     self.salary = зарплата
     self.id = id

класс childemployee (сотрудник1, сотрудник2):
    def __init __ (я, имя, возраст, зарплата, идентификатор):
     self.name = имя
     self.age = возраст
     себя.зарплата = зарплата
     self.id = id
emp1 = employee1 ('суровый', 22,1000)
emp2 = employee2 ('арджун', 23,2000,1234)

печать (emp1.age)
печать (emp2.id)
 

Вывод: 22,1234

Объяснение: В приведенном выше примере я взял два родительских класса «employee1» и «employee2». И дочерний класс «childemployee», который наследует оба родительских класса, создавая экземпляры объектов. 'emp1' и 'emp2' против параметров родительских классов.

Речь шла о наследовании, продвигаясь вперед в объектно-ориентированном программировании на Python, давайте углубимся в «полиморфизм».

Полиморфизм:

Вы все должны были использовать GPS для навигации по маршруту. Разве не удивительно, сколько разных маршрутов вы встретите для одного и того же пункта назначения в зависимости от трафика, с точки зрения программирования это называется " полиморфизм'. Это одна из таких методологий ООП, в которой одну задачу можно выполнить несколькими способами. Проще говоря, - это свойство объекта, которое позволяет ему принимать несколько форм . 2 типа полиморфизм, который разрешается во время компиляции программы.Один из распространенных примеров - «перегрузка метода». Позвольте мне показать вам быстрый пример того же.

Пример:

 класс employee1 ():
def имя (сам):
print ("Жестокое его имя")
def зарплата (самостоятельно):
print («3000 - его зарплата»)

def age (self):
print («ему 22 года»)

класс employee2 ():
def name (self):
print («Рахул его имя»)

def зарплата (самостоятельно):
print («4000 - его зарплата»)

def age (self):
print («ему 23 года»)

def func (obj): // Перегрузка метода
obj.name ()
obj.salary ()
объектвозраст()

obj_emp1 = сотрудник1 ()
obj_emp2 = сотрудник2 ()

func (obj_emp1)
func (obj_emp2)
 

Вывод:

Харшит - его имя
3000 - его зарплата
22 - его возраст
Рахул - его имя
4000 - его зарплата
23 - его возраст

Пояснение:

  • Как указано выше Программа, я создал два класса «employee1» и «employee2» и создал функции для «name», «salary» и «age» и распечатал их значения, не принимая их у пользователя.

  • Теперь добро пожаловать в основную часть, где я создал функцию с параметром «obj» и вызвал все три функции, то есть «имя», «возраст» и «зарплату».

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

Полиморфизм времени выполнения:

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

Пример:

 класс сотрудника ():
   def __init __ (я, имя, возраст, идентификатор, зарплата):
       self.name = имя
       self.age = возраст
       self.salary = зарплата
       self.id = id
def зарабатывать (самостоятельно):
        проходить

класс childemployee1 (сотрудник):

   def заработать (self): // полиморфизм времени выполнения
      print ("денег нет")

класс childemployee2 (сотрудник):

   def зарабатывать (самостоятельно):
       print ("есть деньги")

c = childemployee1
c.заработать (сотрудник)
d = childemployee2
d.earn (сотрудник)
 

Вывод: нет денег, есть деньги

Объяснение: В приведенном выше примере я создал два класса childemployee1 и childemployee2, которые являются производными от одного и того же базового класса employee. не получил денег, тогда как другой получает. Теперь главный вопрос: как это произошло? Итак, если вы присмотритесь, я создал пустую функцию и использовал Pass (оператор, который используется, когда вы не хотите выполнять какую-либо команду или код).Теперь, в двух производных классах, я использовал одну и ту же пустую функцию и использовал оператор печати как «нет денег» и «имеет деньги». Наконец, создал два объекта и вызвал функцию.

Переходя к следующей методологии объектно-ориентированного программирования Python, я расскажу об инкапсуляции.

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

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

Позвольте мне показать вам пример для лучшего понимания.

Пример:

 класс сотрудника (объект):
def __init __ (сам):
self.name = 1234
self._age = 1234
self .__ salary = 1234

объект1 = сотрудник ()
печать (object1.name)
печать (объект1._age)
печать (объект1 .__ зарплата)
 

Вывод:

1234
Отслеживание (последний вызов последним):
1234
Файл «C: /Users/Harshit_Kant/PycharmProjects/test1/venv/encapsu.py», строка 10, в
print (object1.__salary)
AttributeError: Объект «employee» не имеет атрибута «__salary»

Explanation: Вы получите этот вопрос, что такое подчеркивание и ошибка? Ну, класс python обрабатывает частные переменные как (__ salary), к которым нельзя получить прямой доступ.

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

Пример:

 класс сотрудника ():
def __init __ (сам):
self .__ maxearn = 1000000
def зарабатывать (самостоятельно):
print ("заработок: {}".формат (self .__ maxearn))

def setmaxearn (self, заработать): // метод установки, используемый для доступа к закрытому классу
self .__ maxearn = зарабатывать

emp1 = сотрудник ()
emp1.earn ()

emp1 .__ maxearn = 10000
emp1.earn ()

emp1.setmaxearn (10000)
emp1.earn ()

 

Вывод:

доход: 1000000, доход: 1000000, доход: 10000

Объяснение: Использование метода установки обеспечивает косвенный доступ к методу частного класса . Здесь я определил класс сотрудника и использовал (__maxearn), который представляет собой метод установки, используемый здесь для хранения максимального заработка сотрудника, и функцию установки setmaxearn (), которая принимает цену в качестве параметра.

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

Далее в методологии объектно-ориентированного программирования Python рассказывает об одной из ключевых концепций, называемой абстракцией.

Абстракция:

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

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

Пример:

 из abc import ABC, abstractmethod
класс сотрудника (ABC):
def emp_id (self, id, name, age, salary): // Абстракция
проходить

класс childemployee1 (сотрудник):
def emp_id (self, id):
print ("emp_id - 12345")

emp1 = childemployee1 ()
emp1.emp_id (идентификатор)

 

Выходные данные : emp_id - 12345

Explanation: Как вы можете видеть в приведенном выше примере, мы импортировали абстрактный метод, а остальная часть программы имеет родительский и производный классы. Создается экземпляр объекта для базового класса «childemployee», и используются функциональные возможности абстрактного.

Является ли Python на 100% объектно-ориентированным?

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

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

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

Определение объектно-ориентированного программирования | PCMag

Структура языка программирования, в которой данные и связанная с ними обработка («методы») определены как автономные сущности, называемые «объектами». Сегодняшняя норма - языки объектно-ориентированного программирования (ООП), такие как C ++ и Java, предоставляют формальный набор правил для создания объектов и управления ими.Данные хранятся в традиционной реляционной базе данных или в объектной базе данных, если данные имеют сложную структуру. См. Отображение O-R и базу данных объектов.

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

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

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

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

Языки ООП
SIMULA, использовавшийся для моделирования поведения системы в конце 1960-х годов, был первым объектно-ориентированным языком. В 1970-х Smalltalk от Xerox был первым объектно-ориентированным языком программирования, который использовался для создания графического пользовательского интерфейса (см. Xerox Star).ACTOR и Eiffel также раньше были языками ООП.

Сегодня популярными объектно-ориентированными языками являются C ++, C #, Java, JavaScript, Visual Basic.NET и Python. Ниже приводится сравнение основных терминов ООП с традиционным программированием. См. Объектно-ориентированную СУБД.

  ООП Традиционное программирование 

 класс определить данные + обработка

 данные объекта + обработка

 данные атрибута (поле)

 функция метода

 вызов функции сообщения

 создать экземпляр создать структуру
 

Соотношение vs.Моделирование объектов

Вместо отдельных таблиц сотрудников, отделов и должностей класс сотрудников содержит данные и обработку для всех сотрудников. Каждый подкласс (менеджер, секретарь и т. Д.) Имеет свои собственные данные и обработку, но также наследует все от класса сотрудников. Изменения, внесенные в класс сотрудников, влияют на каждый подкласс.

11.1 - Добро пожаловать в объектно-ориентированное программирование

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

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

Так что же такое объектно-ориентированное программирование? Как и многие другие вещи, это, вероятно, легче всего понять, используя аналогию. Оглянитесь вокруг - куда ни глянь - предметы: книги, здания, еда и даже вы. У объектов есть два основных компонента: 1) Список соответствующих свойств (например,грамм. вес, цвет, размер, прочность, форма и т. д.…) и 2) некоторое количество действий, которые они могут проявлять (например, открываться, делать что-то еще горячим и т. д.…). Эти свойства и поведение неразделимы.

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

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

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

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

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

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

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

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

ООП стало фундаментальной частью разработки программного обеспечения.Благодаря повсеместному распространению таких языков, как Java и C ++, вы не сможете разрабатывать программное обеспечение для мобильных устройств, если не понимаете объектно-ориентированный подход. То же самое касается серьезной веб-разработки, учитывая популярность языков ООП, таких как Python, PHP и Ruby.

Разобраться в идее объектно-ориентированного программирования может быть непросто для некоторых ИТ-специалистов. Вам может быть интересно, зачем вам вообще нужны объекты, если вы можете использовать нисходящий подход традиционного структурированного программирования в таких языках, как Visual Basic.

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

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

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

1. Модульность для упрощения поиска и устранения неисправностей

Что-то пошло не так, и вы не знаете, где искать. Проблема в файле Widget, или это WhaleFlumper? Придется ли вам копаться в этом файле «sewage.c»? Надеюсь, вы прокомментировали свой код!

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

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

Мы поможем вам найти вашу следующую работу программиста:

2.Повторное использование кода по наследству

Предположим, что в дополнение к вашему объекту Car одному коллеге нужен объект RaceCar, а другому - объект Limousine. Каждый строит свои объекты отдельно, но обнаруживает между ними общие черты. Фактически, каждый объект - это просто отдельный вид Автомобиля. Здесь техника наследования экономит время: создайте один универсальный класс (Car), а затем определите подклассы (RaceCar и Limousine), которые должны наследовать черты универсального класса.

Конечно, у Limousine и RaceCar есть свои уникальные атрибуты и функции.Если объекту RaceCar нужен метод для «fireAfterBurners», а объекту Limousine требуется шофер, каждый класс может реализовать отдельные функции только для себя. Однако, поскольку оба класса наследуют ключевые аспекты от класса Car, например методы «drive» или «fillUpGas», ваши наследующие классы могут просто повторно использовать существующий код вместо того, чтобы заново писать эти функции.

Что делать, если вы хотите изменить все объекты «Автомобиль», независимо от их типа? Это еще одно преимущество объектно-ориентированного подхода.Просто внесите изменения в свой класс Car, и все объекты car просто унаследуют новый код.

3. Гибкость за счет полиморфизма

Рассматривая этот пример, теперь вам нужно всего несколько драйверов или функций, таких как «driveCar», «driveRaceCar» и «DriveLimousine». Водители RaceCarDrivers имеют некоторые общие черты с водителями LimousineDrivers, но другие вещи, такие как RaceHelmets и BeverageSponsorships, уникальны.

Вот где в игру вступает сладкий полиморфизм объектно-ориентированного программирования.Поскольку одна функция может изменять форму для адаптации к любому классу, в котором она находится, вы можете создать одну функцию в родительском классе Car под названием «drive» - не «driveCar» или «driveRaceCar», а просто «drive». Одна эта функция будет работать с RaceCarDriver, LimousineDriver и т. Д. Фактически, у вас даже может быть «raceCar.drive (myRaceCarDriver)» или «limo.drive (myChauffeur)».

4. Эффективное решение проблем

Такой язык, как C, имеет удивительное наследие в истории программирования, но писать программы на языке сверху вниз - все равно что играть в Jenga в рукавицах.Чем сложнее он становится, тем больше вероятность его обрушения. Между тем, написание программы в функциональном стиле на таком языке, как Haskell или ML, может оказаться рутиной.

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

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

ориентированных | Определение объектно-ориентированного по Merriam-Webster

объектно-ориентированный

| \ Äb-jikt-r-ē-en-təd

, - (ˌ) jekt- \

: относится к объектно-ориентированному программированию, используется или реализуется с помощью него.

объектно-ориентированный язык

.

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

Ваш адрес email не будет опубликован.

2022 © Все права защищены. Карта сайта