А напоследок отведайте волшебного объектно-ориентированного программирования (ООП). Эта технология преобразила ремесло программиста, – так пройдем ли мимо?
Фокус-покус
Вначале дадим слово Паскалю. Если вы работаете в IDE Borland Pascal, введите и запустите следующую программку. Только убедитесь в том, что библиотечный файл «APP.TPU» доступен компилятору (обычно он находится в папке «UNITS», где собраны фирменные библиотечные модули).
{P_61_1 – демонстрация работы Turbo Vision }
uses App;
var A : TApplication;
begin
A.Init;
A.Run;
A.Done;
end.
Как это работает? – не спрашивайте, ведь программка очень проста, что ещё надо? После ее запуска вам откроется следующая картина (рис. 152).
Рис.152 – Окно программы MyApp
Неужто «сломалась» IDE? В самом деле, где меню и окно с текстом программы? Да и статусная строка совсем не та. Но мышка по-прежнему бегает, и клавиатура жива. Можно щелкнуть по слову «Exit» и выйти из программы, или сделать то же самое нажатием Alt+X. Да, друзья, вы наблюдаете действие той самой малюсенькой программки! Ее поведение чудесно, но возможности этим не исчерпаны. Своей мощью она обязана объектам из библиотеки Turbo Vision, на которой построена вся IDE Borland Pascal.
Вместо паяльника
Все восторгаются объектным программированием. А откуда оно взялось?
Представьте, что при покупке телевизора вместо работающего изделия вам вручают его схему и коробку с деталями. И предлагают собрать телевизор самому! Примерно в таком же положении находились когда-то и программисты. Используемые ими библиотеки хранили массу полезных процедур и функций, – своего рода «схемы» для сборки программ. А «деталями» были обрабатываемые данные. Программист распределял эти данные в программе, придавая им нужную структуру, применял к данным в надлежащем порядке процедуры и функции, отслеживая при этом влияние одних данных на другие. Работа эта сродни сборке телевизора! Плодовитость программистов и качество их изделий оставляли желать лучшего, ненадежные программы было трудно править, да и пользоваться ими было неудобно.
Так вернемся к телевизору; что нужно знать мне, его владельцу? Всего лишь несколько кнопок: включить, отключить, выбрать канал, настроить громкость. И все! Остальное пусть будет спрятано. Вот бы и в программировании добиться такого удобства! Изобретатели ООП стремились именно к этой цели – упростить работу со сложной совокупностью данных. Они догадались объединить в одно целое данные и процедуры, их обрабатывающие. Совокупность данных и процедур назвали объектом.
На первый взгляд объект похож на запись. Но, в отличие от записи, большинство данных и процедур объекта спрятано внутри и не видно за его пределами. Снаружи доступно лишь то, что интересует пользователя объекта, – в этом объект похож на модуль (или на собранный телевизор).
На трех китах
Основу ООП составляют три идеи, три «кита», а именно:
• инкапсуляция;
• наследование;
• полиморфизм.
Рассмотрим их в этом порядке.
Примечание. Для примеров этой главы настройте компилятор в режим, совместимый с Borland Pascal.
Инкапсуляция
Инкапсуляция – это объединение данных и обрабатывающих их процедур. Рассмотрим простой пример: построим объект для хранения и обработки информации о человеке. Человеку свойственны такие атрибуты как год рождения, имя и фамилия. Поставим цель упростить работу с этими атрибутами, – создадим объект, способный хранить и распечатывать эту информацию.
Объявление объекта
Объявление объекта похоже на объявление записи, с той разницей, что ключевое слово RECORD заменяют словом OBJECT. В Delphi и совместимом с ним режиме Free Pascal применяют ключевое слово CLASS. Итак, «застолбим» место хранения информации о человеке тремя полями, как это показано ниже.
type TPerson = object
mBearing : integer; { год рождения }
mName : string; { имя }
mFam : string; { фамилия }
end;
Здесь объявлен тип данных TPerson (персона), содержащий три поля с данными о человеке. Для распечатки данных учредим процедуру по имени Report. Но процедура эта особая! Её заголовок помещен внутрь описания объекта следующим образом:
type TPerson = object
mBearing : integer; { год рождения }
mName : string; { имя }
mFam : string; { фамилия }
procedure Report ; { процедура распечатки объекта }
end;
Методы
Процедуры и функции, объявленные внутри объекта, называют методами объекта. Методы, как и поля, – неотъемлемая часть объекта. Но объявить метод недостаточно, надо создать и его тело или, как принято говорить, реализацию метода. Реализация – это подпрограмма (процедура или функция), которая от обычной подпрограммы отличается заголовком: там к имени метода добавляется приставка, указывающая тип объекта, которому принадлежит метод. Реализация метода Report будет очень простой.
procedure TPerson. Report;
begin
Writeln(mBearing:6, 'Фамилия: '+mFam:20, ' Имя: '+mName);
end;
Процедура распечатывает атрибуты человека. Но откуда она берет их? – эти данные не передаются через параметры, и не хранятся в глобальных переменных. Они объявлены как поля объекта, и этого достаточно, чтобы метод объекта получил доступ к ним.
Инициализация, конструктор
Поля объекта, как любые переменные, нуждаются в инициализации. Как проще осуществить её? Можно присвоить значения полям так, как это делается для записей.
var P : TPerson; { переменная-объект }
begin
P.mFam:=’Сидоров’;
P.mName:= ’Тимофей’;
end.
Но, когда полей много, вы забудете что-то – в этом слабость идеи. Куда надежней учредить особый метод для инициализации полей. Такой метод и назван особо – конструктор. Вместо слова PROCEDURE перед именем конструктора так и пишут: CONSTRUCTOR. Назвать конструктор можно как угодно, но по традиции ему дают имена Init (инициализировать) или Create (создать). Например, для нашего объекта объявить конструктор и реализовать его тело можно так:
type TPerson = object
{... }
{ заголовок конструктора внутри объекта }
constructor Init(aBearing: integer; const aName, aFam : string);
end;
{ реализация конструктора }
constructor TPerson.Init(aBearing: integer; const aName, aFam : string);
begin
mBearing:= aBearing; mName:= aName; mFam:= aFam;
end;
В этом примере конструктор Init копирует три своих параметра в поля объекта. Теперь переменную-объект P можно инициализировать вызовом конструктора.
var P : TPerson; { переменная-объект }
begin
P.Init(1995, 'Мария', 'Рыбкина');
Так ни одно поле объекта не будет пропущено, – за этим присмотрит компилятор!
Вот пока все, что следует сказать об инкапсуляции. Приведенный ниже пример «P_61_2» демонстрирует объект типа TPerson: здесь описана его структура и реализация методов, а затем объявлены две переменные, выполнена их инициализация и распечатка полей.
{ P_61_2 Программа с применением объекта типа «человек» (персона) }
type TPerson = object
mBearing : integer; { год рождения }
mName : string; { имя }
mFam : string; { фамилия }
constructor Init(aBearing: integer; const aName, aFam : string);
procedure Report; { процедура распечатки объекта }
end;
{--- Реализация двух методов объекта ---}
constructor TPerson.Init(aBearing: integer; const aName, aFam : string);
begin
mBearing := aBearing; mName := aName; mFam := aFam;
end;
procedure TPerson.Report;
begin
Writeln(mBearing:6, 'Фамилия: '+mFam:20, ' Имя: '+mName);
end;
var P1, P2 : TPerson; { две переменных объектного типа }
begin {--- Главная программа ---}
P1.Init(1985, 'Иван', 'Грозный');
P2.Init(1995, 'Мария', 'Рыбкина');
P1.Report;
P2.Report;
Readln;
end.
Наследование
Кажется, что инкапсуляция не упростила программирование. Да, это так, если рассматривать её в отрыве от других механизмов ООП: наследования и полиморфизма. Выигрыш мы ощутим, когда в ход пойдут все рычаги.
Наследование даёт возможность создавать новые типы объектов на основе существующих. Вновь создаваемые типы объектов – потомки – приобретают в наследство поля и методы своих предков. И вдобавок могут содержать новые поля и методы, а также изменять унаследованные.
Например, взяв почти готовый объект – окно в библиотеке, – программист добавляет к нему свои поля, методы и получает другой тип окна, работающий схожим образом, но с учетом потребностей программиста. При этом ему не придется вникать в тонкости объекта-предка, достаточно ознакомиться лишь с несколькими основными методами (подобно тому, как пользователю телевизора хватает лишь нескольких кнопок). Не нужен даже исходный текст модуля с описанием объекта-предка!
И это не все. Постройка одних объектов на основе других формирует иерархию родственных объектов. С разными объектами в этой иерархии можно обращаться сходным образом, – это и есть полиморфизм. Буквальный перевод этого слова – «многоструктурность» – почти ничего не объясняет. Принципы наследования и полиморфизма легче понять на примере.
Приборостроение
Я знаю, чем напичкан ваш дом, – электрическими приборами. И простыми, такими, как лампочка или утюг. И сложными, – телевизор, стиральная машина, компьютер, наконец. Взглянем на них глазами программиста: любой такой прибор, выражаясь языком ООП, обладает, по крайней мере, двумя общими «методами» – включить и отключить. В разных приборах эти операции выполняются по-разному, но в целом они сходны. Можно сказать, что эти методы – общие свойства всех электроприборов.
Если бы приборы создавал программист, то построил бы их на базе общего предка – абстрактного (воображаемого) электрического прибора. Этот прибор обладал бы двумя методами: включить и отключить. На Паскале этот абстрактный электроприбор был бы объявлен так:
type Электроприбор = object
procedure Включить; virtual ;
procedure Отключить; virtual ;
end;
Здесь встречаем новое «волшебное» словечко – VIRTUAL, что значит «воображаемый». Это ключевое слово Паскаля следует за объявлением тех методов объекта, которые разрешено изменять в его наследниках. Изменение метода в наследниках называют переопределением метода. Итак, слово VIRTUAL указывает компилятору, что в наследниках методы включения и отключения прибора могут быть изменены в соответствии с особенностями этих наследников. К примеру, лампочка и телевизор включаются по-разному.
Основав абстрактный электроприбор, построим на нём прибор «чисто конкретный», например, телевизор.
type Телевизор = object (Электроприбор)
procedure Включить; virtual ;
procedure Отключить; virtual ;
procedure Выбрать_канал;
procedure Настроить_громкость;
procedure Настроить_яркость;
end;
Поскольку телевизор порожден от электроприбора, название его предка – «электроприбор» – указано в скобках за ключевым словом OBJECT. Наследник обязан помнить о предке, ссылаться на него, иначе не получит своего наследства – полей и методов. Виртуальные методы включить и отключить объявлены в наследнике точно так же, но будут реализованы иначе. К ним добавлены ещё три метода, характерные именно для телевизора. Схожим образом строятся и другие «конкретные» электроприборы. В результате сформируется иерархия родственных объектов, показанная на рис. 153.
Рис.153 – Иерархия электрических приборов
Гражданское строительство
Но все это лишь присказка, теперь испытаем наследование и полиморфизм в деле. Создадим на базе спроектированного ранее объекта TPerson (человек) два новых типа данных: военнослужащий (TMilitary) и гражданский чиновник (TCivil), иерархия этих типов изображена на рис. 154. Эти новые типы «людей» будут содержать дополнительные поля с характерной для наследников информацией. Вдобавок изменим конструктор Init и метод Report с тем, чтобы учесть наличие новых полей. Конструктор будет содержать дополнительный параметр, а процедура распечатки – выводить на экран ещё одно поле объекта.
Рис.154 – Иерархия «человеческих» типов
Объявление
Начнем с военнослужащего, чем разнится он от простых смертных? Гордым воинским званием – от рядового до маршала. Для хранения воинского звания в объекте TMilitary добавим строковое поле mRank (Rank – звание). Ясно, что при создании объекта конструктором надо указать этот элемент. Добавим ещё один параметр конструктору объекта Init – параметр aRank, и тогда заголовок конструктора в объекте TMilitary станет таким.
constructor Init(aBearing: integer; const aName, aFam, aRank : string);
В новом конструкторе больше параметров, и работать он будет, в сравнении с предком, чуть иначе. Другими словами, в наследнике он переопределен. А если так, то где же волшебное слово VIRTUAL? Его здесь нет и не должно быть, поскольку конструктор виртуален по определению.
Теперь обратимся к процедуре распечатки Report. В наследнике она, кроме прочего, должна распечатать поле воинского звания, а значит, будет переопределена. Поэтому и объявлена виртуальной, причем и в наследнике TMilitary, и в его предке TPerson. Это необходимо, поскольку лишь виртуальный метод предка может быть виртуальным у наследника: виртуальность передается по наследству. С учетом всего сказанного, объявления типов TPerson и TMilitary теперь будут такими.
TPerson = object
mBearing : integer; { год рождения }
mName : string; { имя }
mFam : string; { фамилия }
constructor Init(aBearing: integer; const aName, aFam : string);
procedure Report; virtual ;
end;
TMilitary = object (TPerson)
mRank : string; { воинское звание }
constructor Init(aBearing: integer; const aName, aFam,
aRank : string);
procedure Report; virtual ;
end;
Подытожим все изменения. В предке TPerson процедура Report стала виртуальной. В наследнике TMilitary добавлено поле mRank, а также изменены два метода: конструктор и процедура Report.
«Отселение» в отдельный модуль
Настало время реализовать методы наследника. Но прежде, чем взяться за это, совершим одно полезное дельце – переместим объект-предок TPerson в отдельный модуль. Именно так поступают профессионалы, создавая библиотеки объектов. Порядок создания программного модуля подробно изложен в главе 59, вкратце я напомню основные шаги.
Итак, создайте новый файл, перенесите туда через буфер обмена объявление типа TPerson и реализацию его методов. Объявление объекта разместите в секции INTERFACE модуля, а реализацию – в секции IMPLEMENTATION. И не забудьте объявить виртуальной процедуру Report. Дайте модулю имя PERSON и сохраните под именем «PERSON.PAS». У вас получится файл, показанный ниже. В нём объявлен ещё один тип данных – указатель на объект PPerson, но к нему обратимся позже.
unit Person ; { Модуль, содержащий описание и реализацию объекта «ЧЕЛОВЕК» }
interface
type PPerson = ^TPerson ; { указатель на объект «ЧЕЛОВЕК» }
TPerson = object
mBearing : integer; { год рождения }
mName : string; { имя }
mFam : string; { фамилия }
constructor Init(aBearing: integer; const aName, aFam : string);
procedure Report; virtual ;
end;
implementation
{--- Реализация объекта «ЧЕЛОВЕК» ---}
constructor TPerson.Init(aBearing: integer; const aName, aFam : string);
begin
mBearing := aBearing;
mName := aName;
mFam := aFam;
end;
procedure TPerson.Report;
begin
Writeln(mBearing:6, 'Фамилия: '+mFam:20, ' Имя: '+mName);
end;
end.
Теперь то, что переехало в модуль Person, из первичного файла проекта удалим, и добавим в начале программы ссылку для импорта модуля.
USES Person;
Сохраните новую версию файла под именем «P_61_3» и убедитесь, что она компилируется без ошибок. Затем вставьте в первичный файл приведенное ранее объявление типа для наследника TMilitary. В итоге заготовка будущей программы станет такой.
{ P_61_3 – Демонстрация принципов наследования и полиморфизма }
uses Person ; { Объект TPerson импортируется из модуля Person }
type { объект «ВОЕННОСЛУЖАЩИЙ» }
TMilitary = object (TPerson)
mRank : string; { воинское звание }
constructor Init(aBearing: integer; const aName, aFam, aRank : string);
procedure Report; virtual ;
end;
begin
end.
Реализация методов
Отсюда приступим к реализации переопределенных методов нового объекта. Начнем с конструктора. Конечно, он мог бы повторить действия объекта-предка, но это неразумно. Ведь цель объектной технологии – упростить программирование, избежать повторов, не так ли? Избежать повтора здесь очень просто: внутри конструктора наследника вызовем конструктор предка, передав ему нужные параметры.
TPerson.Init(aBearing, aName, aFam);
Вызов конструктора предка содержит имя этого предка – префикс TPerson. Обращение потомка к методам предка – обычная практика. По этой причине в Паскале учреждено ключевое слово INHERITED – «унаследованный». Если предварить им вызов унаследованного метода, то префикс с именем предка станет излишним.
inherited Init(aBearing, aName, aFam);
В таком вызове унаследованного метода трудней ошибиться. Ведь иерархия предков может быть глубокой, а представленный здесь способ вызывает метод непосредственного (ближайшего) предка, что, обычно, и требуется.
Итак, поля, унаследованные от предка, инициализированы конструктором, унаследованным от него же. Оставшееся поле mRank заполним как обычно, в результате конструктор наследника приобретет такой вид.
constructor TMilitary.Init(aBearing: integer; const aName, aFam,
aRank : string);
begin
inherited Init(aBearing, aName, aFam); { вызов метода предка }
mRank:= aRank;
end;
Переходим к методу Report наследника. Здесь, вдобавок к прочим данным, надо распечатать ещё и воинское звание. Прочие данные распечатаем унаследованным методом Report, а воинское звание – дополнительным оператором печати. Вы уже догадались, что реализация метода будет такова.
procedure TMilitary.Report;
begin
inherited Report; { вызов метода предка }
Writeln('Воинское звание: '+mRank);
end;
Породив «военного человека», возьмёмся за мирное строительство, создадим объект, исполняющий роль гражданского служащего. Назовем его TCivil, а род его пойдет от того же предка TPerson. У гражданских своя гордость и своя служебная лестница, ступеньки которой – категории – нумеруются числами. Хранить информацию о карьерном росте будем в числовом поле, назовем его mLevel – «уровень». Так же, как и для военного, нам придется дополнить конструктор объекта и метод распечатки Report. Ход рассуждений будет прежним, а потому не буду повторять его, сделайте эту работу сами.
Сотворив наследников «человека» – объекты TMilitary и TCivil, мы почти разобрались в механизме наследования. А где же полиморфизм? В чем он проявляется? Для ответа обратимся к динамическим объектам.
Динамические объекты
Динамические переменные знакомы нам с 52-й главы. Указатели на объекты ничем не отличаются от таковых для других типов данных. Например, указатель на тип TPerson объявляется так:
type PPerson = ^TPerson;
Теперь можно объявить переменную этого типа, взять для неё память в куче, а затем инициализировать поля конструктором.
var P : PPerson; { указатель на объект }
begin
New(P); { выделение памяти в куче }
P^.Init(1985, 'Иван', 'Грозный'); { инициализация объекта }
В серьезных программах объекты обычно используют динамически, а выделение памяти и инициализацию выполняют там на каждом шагу. Потому в Паскаль введена функция New, совмещающая эти действия. Функция New подобна процедуре New, но вдобавок вызывает ещё и конструктор объекта. Функция принимает два странных параметра: тип-указатель на объект и конструктор этого объекта, а возвращает указатель на созданный объект. Так, динамический объект типа TPerson может быть порожден и инициализирован одним оператором.
P:= New( PPerson , Init(1985, 'Иван', 'Грозный'));
Обратите внимание, что первый параметр функции – это тип-указатель PPerson, а не тип объекта TPerson!
Примечание. В языке Delphi и совместимом с ним режиме Free Pascal применяют иной синтаксис вызова конструктора, например:
var P : TPerson; { это указатель на объект! }
...
P:= TPerson.Init(1985, 'Иван', 'Грозный'); { создается динамический объект }
Дело в том, что все объекты в Delphi – это динамические переменные, и переменная типа TPerson является указателем на объект. Для создания таких объектов применяют не функцию New, а вызов конструктора с префиксом, совпадающим с названием типа объекта.
Полиморфизм
Теперь, после знакомства с динамическими объектами, вернемся к полиморфизму. Предположим, что в программе объявлены указатели трех типов.
var P1 : PPerson; { указатель на предка }
P2 : PMilitary; { указатель на потомка }
P3 : PCivil; { указатель на потомка }
Здесь P1 является указателем на предка, а P2 и P3 – на разных его потомков. Отчасти полиморфизм состоит в том, что указателю на предка разрешено присваивать указатели на любого его потомка, то есть следующие операторы не вызовут протеста компилятора.
P1:= P2;
P1:= P3;
Скажете, пустая формальность? Зря вы так! Воистину здесь скрыт глубокий смысл, поскольку через указатель на предка можно вызывать методы его потомков. Но при условии, что эти методы унаследованы от предка как виртуальные. Так, в следующем примере указателю P1 трижды присваиваются указатели на объекты разных типов: сначала на предка TPerson, а затем на двух его потомков, после чего всякий раз вызывается виртуальный метод Report. Но в реальности происходит вызов трех разных методов Report – соответственно типу объекта, на который в текущий момент ссылается указатель P1. Так срабатывает механика полиморфизма!
P1:= New( PPerson , Init(1985, 'Иван', 'Грозный'));
P1^.Report; { вызывается TPerson.Report }
P1:= New( PCivil , Init(1995, 'Мария', 'Рыбкина', 12));
P1^.Report; { вызывается TCivil.Report }
P1:= New( PMilitary , Init(1985, 'Андрей', 'Быков', 'Майор'));
P1^.Report; { вызывается TMilitary.Report }
Кажется, что полиморфизм одушевляет объект и делает его умнее: объект сам «понимает», как ему исполнить то, или иное желание программиста. Тот лишь вызывает нужный метод, не вникая в детали. Это похоже на управление телевизором или другим прибором. Стоит подать напряжение, и все они включатся: хоть и по-разному, но каждый по-своему правильно.
Но мощная механика полиморфизма срабатывает лишь для родственных объектов, состоящих в отношении предок-потомок. Именно в таких отношениях находятся созданные нами объекты. А вот пример иного рода.
type TA = object
constructor Init;
procedure Report; virtual;
end;
TB = object
constructor Init;
procedure Report; virtual;
end;
Здесь объявлены два типа объектов с одноименными виртуальными методами. Но полиморфизмом тут и не пахнет, поскольку объекты не родственны меж собой!
В завершение темы изучите программу «P_61_3», где собрано все, что было сказано о «человечьих» объектах.
{ P_61_3 – Демонстрация принципов наследования и полиморфизма }
uses Person ; { Объект TPerson импортируется из модуля Person }
type PMilitary = ^TMilitary; { указатель на объект «ВОЕННОСЛУЖАЩИЙ» }
TMilitary = object (TPerson)
mRank : string; { воинское звание }
constructor Init(aBearing: integer; const aName, aFam,
aRank : string);
procedure Report; virtual ;
end;
PCivil = ^TCivil; { указатель на объект «ГРАЖДАНСКИЙ СЛУЖАЩИЙ» }
TCivil = object (TPerson)
mLevel : integer; { должностная категория }
constructor Init(aBearing: integer; const aName, aFam : string;
aLevel: integer);
procedure Report; virtual ;
end;
{--- Реализация объекта «ВОЕННОСЛУЖАЩИЙ» ---}
constructor TMilitary.Init(aBearing: integer; const aName, aFam,
aRank : string);
begin
inherited Init(aBearing, aName, aFam);
mRank:= aRank;
end;
procedure TMilitary.Report;
begin
inherited Report;
Writeln('Звание: '+mRank);
end;
{--- Реализация объекта «ГРАЖДАНСКИЙ СЛУЖАЩИЙ» ---}
constructor TCivil.Init(aBearing: integer; const aName, aFam : string;
aLevel: integer);
begin
inherited Init(aBearing, aName, aFam);
mLevel:= aLevel;
end;
procedure TCivil.Report;
begin
inherited Report;
Writeln('Категория: ', mLevel);
end;
var Persons : array[1..3] of PPerson; { массив указателей на ПРЕДКА }
i : integer;
begin {--- Главная программа ---}
{ Массив заполняется объектами РАЗНЫХ, но родственных типов }
Persons[1]:= New( PPerson , Init(1985, 'Иван', 'Семенов'));
Persons[2]:= New( PCivil , Init(1995, 'Мария', 'Рыбкина', 12));
Persons[3]:= New( PMilitary , Init(1985, 'Андрей', 'Быков', 'Майор'));
{ В ходе распечатки вызывается метод ФАКТИЧЕСКОГО объекта }
for i:=1 to 3 do Persons[i]^.Report;
Readln;
end.
Сокрытие полей и методов
Объяснять ли вам, из чего строят современные программы? Из сотен «умных» объектов, которые образуют ветвистую иерархию родственных связей, открывающую простор полиморфизму.
Многие объекты фирменных библиотек – это полуфабрикаты, требующие лишь небольшой настройки под конкретное применение. В ходе такой настройки программист добавляет к базовому объекту свои поля и методы. И здесь порой случается то же, что при использовании библиотечных модулей: имя, назначенное программистом, может совпасть с уже объявленным именем в предке. И тогда имена могут конфликтовать. В библиотечных модулях эта проблема решается скрытием большей части переменных, процедур и функций в невидимой извне секции реализации IMPLEMENTATION.
Схожий прием используют и в объектном программировании. Поля и методы, доступ к которым наследникам не нужен, прячут в объекте-предке так, что они становятся невидимыми за пределами предка. И тогда спрятанные имена можно использовать в наследниках повторно по иному назначению. Не будет ли здесь путаницы? Нет, поскольку методы предка не знают о новых именах и обращаются к старым. А методы наследника не видят старых имен и обращаются к новым. Разумеется, что разработчик объекта-предка тщательно отбирает те поля и методы, что потребуются создателям потомков.
Сокрытие имен объекта организовано очень просто: в объявление объекта вставляют ключевые слова PRIVATE (личный) и PUBLIC (общедоступный). Эти слова разбивают объявление объекта на две части – приватную и общедоступную, например:
type TParent = object { объект–предок }
private
A, B : integer;
function Calc(arg: integer): integer;
public
Constructor Init(a, b : integer)
function GetSum: integer; virtual;
end;
Здесь поля A и B, а также функция Calc, скрыты от взоров потомков. Поэтому программист, импортировавший объект типа TParent, может спокойно добавить в него свои поля или методы с теми же самыми именами, например, так:
type TChild = object ( TParent ) { объект–наследник }
A, B : string;
procedure Calc;
...
end;
Здесь в потомке поля A и B имеют другой тип, а имя Calc принадлежит не функции, а процедуре. Но и сейчас поля и методы предка с этими же именами все ещё существуют! Но доступны только предку, вот и все.
А если в объявлении объекта не указаны ключевые слова PRIVATE и PUBLIC? Тогда все его поля и методы по умолчанию будут общедоступными.
Итак, мы рассмотрели идеи и механизмы, лежащие в основе объектно-ориентированного программирования. К сожалению, одной главы маловато для освоения всех тонкостей этой технологии – на то есть другие книги. Объектные технологии – это настоящее и будущее программирования, не жалейте времени на их освоение. Здесь, как и во всем, важна практика. В начале главы я дал пример использования библиотеки Turbo Vision. Изучение этой и ей подобных библиотек – прекрасный способ освоения объектной технологии, подробное описание библиотеки можно найти в Сети и в литературе.
Итоги
• Объектно-ориентированное программирование – это современная технология быстрой разработки крупных и надежных программ.
• Объект – это сложный тип данных, совмещающий в себе собственно данные и процедуры, обрабатывающие их.
• Объектно-ориентированное программирование основано на трех дополняющих друг друга механизмах: инкапсуляции, наследовании и полиморфизме.
• Инкапсуляция – это объединение данных и процедур, их обрабатывающих, в едином объекте.
• Наследование позволяет создавать новые типы объектов на базе существующих. Так создается иерархия родственных объектов.
• Полиморфизм состоит в схожем поведении объектов родственных типов.
А слабо?
А) Разработайте иерархию «человечьих» объектов в соответствии со следующим рисунком (новые типы объектов выделены цветом).
Дайте новым типам объектов подходящие имена, дополните их надлежащими полями, переопределите конструкторы и метод Report. Затем исследуйте механизм полиморфизма на предке и всех его потомках.
Б) Мощность множеств в Паскале не превышает 256, и часто этого бывает недостаточно. Сконструируем свой тип множеств, назовем его TBigSet, мощность которого составит 65536 (соответствует диапазону для типа Word). Оформим это множество как объект.
type
TSetArray = array [0..4096] of word; { хранит 65536 бит (4096*16) }
PSetArray = ^ TSetArray; { тип-указатель на массив }
TBigSet = object
mArray : PSetArray; { указатель на динамический массив }
Constructor Init; { создает динамический массив mArray )
Destructor Done; { освобождает память, занятую массивом }
procedure ClearAll; { опустошает множество }
procedure SetAll; { делает множество полным }
procedure Insert(N); { вставляет элемент N в множество }
procedure Delete(N); { удаляет элемент N из множества }
function Member(N):Boolean; { проверяет принадлежность N к множеству }
function IsEmpty:Boolean; { проверяет пустоту множества }
procedure Union(BS: TBigSet); { добавляет другое множество }
procedure InterSect(BS: TBigSet); { формирует пересечение множеств }
procedure Load(var F: text); { вводит множество из файла }
procedure Save(var F: text); { выводит множество в текстовый файл }
end;
Примените здесь сведения из главы 48, а также идеи из задачи 49-В (глава 49). Так, включение в множество и исключение из него элемента N может быть выполнено установкой и сбросом бита в массиве mArray^.
mArray^[N div 16]:= mArray^[N div 16] or (1 shl (N mod 16))
mArray^[N div 16]:= mArray^[N div 16] and not (1 shl (N mod 16))
Объединение с другим множеством Union(BS:TBigSet) можно сделать логическим суммированием массивов:
for I:=0 to 4095 do mArray^[ I ]:= mArray1^[ I ] or BS.mArray^[ I ]
И так далее. Напишите реализацию всех методов объекта и примените его к решету Эратосфена и прочим задачам из главы 38.