1. Введение

Концепция объектно-ориентированного программирования подразумевает,
что основой управления процессом реализации программы является передача
сообщений объектам. Поэтому объекты должны определяться совместно с
сообщениями, на которые они должны реагировать при выполнении программы. В
этом состоит главное отличие ООП от процедурного программирования, где
отдельно определённые структуры данных передаются в процедуры (функции) в
качестве параметров. Таким образом, объектно-ориентированная программа
состоит из объектов – отдельных фрагментов кода, обрабатывающего данные,
которые взаимодействуют друг с другом через определённые интерфейсы.
Объектно-ориентированный язык программирования должен обладать
следующими свойствами:
1. абстракции – формальное о качествах или свойствах предмета путем
мысленного удаления некоторых частностей или материальных объектов;
2. инкапсуляции – механизма, связывающего вмести код и данные, которыми
он манипулирует, и защищающего их от внешних помех и некорректного
использования;
3. наследования – процесса, с помощью которого один объект приобретает
свойства другого, т.е. поддерживается иерархической классификации;
4. полиморфизма – свойства, позволяющего использовать один и тот же
интерфейс для общего класса действий.
Разработка объектно-ориентированных программ состоит из следующих
последовательных работ:
— определение основных объектов, необходимых для решения данной
задачи;
— определение закрытых данных (данных состояния) для выбранных
объектов;
— определение второстепенных объектов и их закрытых данных;
— определение иерархической системы классов, представляющих
выбранные объекты;
— определение ключевых сообщений, которые должны обрабатывать
объекты каждого класса;
— разработка последовательности выражений, которые позволяют
решить поставленную задачу;
— разработка методов, обрабатывающих каждое сообщение;
— очистка проекта, то есть устранение всех вспомогательных
промежуточных материалов, использовавшихся при проектировании;
— кодирование, отладка, компоновка и тестирование.
Объектно-ориентированное программирование позволяет программисту
моделировать объекты определённой предметной области путем программирования
их содержания и поведения в пределах класса. Конструкция «класс»
обеспечивает механизм инкапсуляции для реализации абстрактных типов данных.
Инкапсуляция как бы скрывает и подробности внутренней реализации типов, и
внешние операции и функции, допустимые для выполнения над объектами этого
типа.

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

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

3. Объекты

Базовым в объектно-ориентированном программировании является понятие
объекта. Объект имеет определённые свойства. Состояние объекта задаётся
значениями его признаков. Объект «знает», как решать определённые задачи,
то есть располагает методами решения. Программа, написанная с
использованием ООП, состоит из объектов, которые могут взаимодействовать
между собой.
Ранее отмечалось, что программная реализация объекта представляет
собой объединение данных и процедур их обработки. Переменные объектного
типа называют экземплярами объекта. Здесь требуется уточнение – экземпляр
можно лишь формально назвать переменной. Его описание даётся в предложение
описания переменных, но в действительности экземпляр – нечто большее, чем
обычная переменная.
В отличие от типа «запись», объектный тип содержит не только поля,
описывающие данные, но также процедуры и функции, описания которых
содержится в описании объекта. Эти процедуры и функции называют методами.
Методам объекта доступны его поля. Следует отметить, что методы и их
параметры определяются в описании объекта, а их реализация даётся вне этого
описания, в том мест программы, которое предшествует вызову данного метода.
В описании объекта фактически содержаться лишь шаблоны обращения к методам,
которые необходимы компилятору для проверки соответствия количества
параметров и их типов при обращении к методам. Вот пример описания
объекта[1]:
Type
Location = object
X,Y: Integer;
Procedure Init(InitX, InitY: Integer);
Function GetX: Integer;
Function GetY: Integer;
End;
Здесь описывается объект, который может использоваться в дальнейшем,
скажем, в графическом режиме и который предназначен для определения
положения на экране произвольного графического элемента. Объект описывается
с помощью зарезервированных слов
object…end, между которыми находиться описание полей и методов. В нашем
примере объект содержит два поля для хранения значений графических
координат, а так же для описания процедуры и двух функций — это методы
данного объекта. Процедура предназначена для задания первоначального
положения объекта, а функция – для считывания его координат.

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

Инкапсуляция является важнейшим свойством объектов, на котором
строится объектно-ориентированное программирование. Инкапсуляция
заключается в том, что объект скрывает в себе детали, которые несущественны
для использования объекта. В традиционном подходе к программированию с
использованием глобальных переменных программист не был застрахован от
ошибок, связанных с использованием процедур, не предназначенных для
обработки данных, связанных с этими переменными. Предположим, например, что
имеется «не-ООП» программа, предназначенная для начисления заработной платы
сотрудникам некой организации, а в программе имеются два массива. Один
массив хранит величину заработной платы, а другой – телефонные номера
сотрудников (для составления отчёта для налоговой инспекции). Что
произойдёт, если программист случайно перепутает эти массивы? Очевидно, для
бухгалтерии начнутся тяжёлые времена. «Жёсткое» связание данных и процедур
их обработки в одном объекте позволит избежать неприятностей такого рода.
Инкапсуляция и является средством организации доступа к данным только через
соответствующие методы.
В нашем примере описание объекта процедура инициализации Init и
функции GetX и GetY уже не существуют как отдельные самостоятельные
объекты. Это неотъемлемые части объектного типа Location. Если в программе
имеется описание нескольких переменных указанного типа, то для каждой
переменной резервируется своя собственная область памяти для хранения
данных, а указатели на точки входа в процедуру и функции – общие. Вызов
каждого метода возможен только с помощью составного имени, явно
указывающего, для обработки каких данных предназначен данный метод.

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

Наследование – это ещё одно базовое понятие объектно-ориентированного
программирования. Наследование позволяет определять новые объекты,
используя свойства прежних, дополняя или изменяя их. Объект-наследник
получает все поля и методы «родителя», к которым он может добавить свои
собственные поля и методы или заменить («перекрыть») их своими методами.
Пример описания объекта-наследника даётся ниже:
Tipe
Point = object(Location)
Visible: Boolean;
Procedure Int(IntX, IntY: Integer);
Procedure Show;
Procedure Hide;
Function IsVisible: Boolean;
Procedure MoveTo(NewX, NewY: Integer);
End;
Наследником здесь является объект Point, описывающий графическую
точку, а родителем – объект Location. Наследник не содержит описание полей
и методов родителя. Имя последнего указывается в круглых скобках после
слова object. Из методов наследника можно вызывать методы родителя. Для
создания наследника не требуется иметь исходный текст объекта родителя.
Объект-родитель может быть уже в составе оттранслированного модуля.
В чём привлекательность наследования? Если некий объект был уже
определён и отлажен, он может быть использован и в других программах. При
этом может оказаться, что новая задача отличается от предыдущей, и
возникает необходимость некоторой модификации как данных, так и методов их
обработки. Программисту приходится решать дилемму – создания объектов
заново или использовать результаты предыдущей работы, применяя механизм
наследования. Первый путь менее эффективен, так как требует дополнительных
затрат времени на отладку и тестирование. Во втором случае часть этой
работы оказывается выполненной, что сокращает время на разработку новой
программы. Программист при этом может и не знать деталей реализации объекта-
родителя.
В нашем примере к объекту, связанному с определением положения
графического элемента, просто добавилось новое поле, описывающее признак
видимости графической точки, и несколько новых методов, связанных с режимом
отображения точки и её преобразованиями.

6. Виртуальные методы

Наследование позволяет создавать иерархические, связанные отношениями
подчинения, структуры данных. Следует, однако, заметить, что при
использовании этой возможности могут возникнуть проблемы. Предположим, что
в нашей графической программе необходимо определить объект Circle, который
является потомком другого объекта Point:
Type
Circle = object (point)
Radius: Integer;
Procedure Show;
Procedure Hide;
Procedure Expand(ExpandBy: Integer);
Procedure Contact(ContactBy: Integer);
End;
Новый объект Circle соответствует окружности. Поскольку свойства
окружности отличаются от свойств точки, в объекте-наследнике придется
изменять процедуры Show и Hide, которые отображают окружность и удаляют её
изображение с экрана. Может оказаться, что метод Init (см. предыдущий
пример) объекта Circle, унаследованный от объекта Point, также использует
методы Show и Hide, впредь во время трансляции объекта Point использует
ссылки на старые методы. Очевидно в объекте Circle они работать не будут.
Можно, конечно, попытаться «перекрыть» метод Init. Чтобы это сделать, нам
придётся полностью воспроизвести текст метода. Это усложни работу, да и не
всегда возможно, поскольку исходного текста программы может не оказаться
под рукой (если объект-родитель уже находиться в оттранслированном модуле).
Для решения этой проблемы используется виртуальный метод. Связь между
виртуальным методом и вызывающими их процедурами устанавливается не во
время трансляции (это называется ранним связанием), а во время выполнения
программы (позднее связание.
Чтобы использовать виртуальный метод, необходимо в описании объекта
после заголовка метода добавить ключевое слово virtual. Заголовки
виртуальных методов родителя и наследника должны в точности совпадать.
Инициализация экземпляра объекта, имеющего виртуальные методы, должна
выполняться с помощью специального метода – конструктора. Конструктор
обычно присваивает полям объекта начальные значения и выполняет другие
действия по инициализации объекта. В заголовке метода-конструктора слово
procedure заменяется словом constructor. Действия обратные действиям
конструктора, выполняет ещё один специальный метод – деструктор. Он
описывается словом destructor.
Конструктор выполняет действия по подготовке позднего связывания. Эти
действия заключаются в создании указателя на таблицу виртуальных методов,
которая в дальнейшем используется для поиска методов. Таблица содержит
адреса всех виртуальных методов. При вызове виртуального метода по его
имени определяется адрес, а затем по этому адресу передается управление.
У каждого объектного типа имеется своя собственная таблица виртуальных
методов, что позволяет одному и тому же оператору вызывать разные
процедуры. Если имеется несколько экземпляров объектов одного типа, то
недостаточно вызвать конструктор для одного из них, а затем просто
скопировать этот экземпляр во все остальные. Каждый объект должен иметь
свой собственный конструктор, который вызывается для каждого экземпляра. В
противном случае возможен сбой в работе программы.
Заметим, что конструктор или деструктор, могут быть «пустыми», то есть
не содержать операторов. Весь необходимый код в этом случае создается при
трансляции ключевых слов construct и destruct.

7. Динамическое создание объектов

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

8. Полиморфизм

Полиморфизм заключается в том, что одно и то же имя может
соответствовать различным действиям в зависимости от типа объекта. В тех
примерах, которые рассматривались ранее, полиморфизм проявлялся в том, что
метод Init действовал по-разному в зависимости от того, является объект
точкой или окружностью. Полиморфизм напрямую связан с механизмом позднего
связывания. Решение о том, какая операция должна быть выполнена в
конкретной ситуации, принимается во время выполнения программы.
Следующий вопрос, связанный с использованием объектов, заключается в
совместимости объектных типов. Полезно знать следующее. Наследник сохраняет
свойства совместимости с другими объектами своего родителя. В правой части
оператора присваивания вместо типов родителя можно использовать типы
наследника, но не наоборот. Таким образом, в нашем примере допустимы
присваивания:
Var
Alocation : Location;
Apoin : Point;
Acircle : Circle;
Alocation :=Apoint
Apoint := Acrcle;
Alocation := Acircle;
Дело в том, что наследник может быть более сложным объектом,
содержащим поля и методы, поэтому присваиваемые значения экземпляра объекта-
родителя экземпляру объекта-наследника может оставить некоторые поля
неопределёнными и, следовательно, представляет потенциальную опасность. При
выполнении оператора присвоения копируются только те поля данных, которые
являются общими для обоих типов.

————————
[1] Выполняется на языке Turbo Pascal, начиная с версии 5.0. Далее все
примеры даны для выполнения на этом языке программирования.