Книга: Технологии программирования

Приложение 4 ЭЛЕМЕНТЫ ЯЗЫКА OBJECT PASCAL

Приложение 4

ЭЛЕМЕНТЫ ЯЗЫКА OBJECT PASCAL

1. МОДУЛЬ В OBJECT PASCAL

Язык объектно-ориентированного программирования Object Pascal применяется при работе в среде визуального программирования Delphi. Язык Object Pascal в основном включает "старый" язык Borland Pascal.

Программы на языке Object Pascal состоят из нескольких файлов: файла проекта (Delphi Project) с расширением *.dpr, одного или нескольких файлов модулей (Unit) с расширением *.pas и файлов дизайнера экранных форм с расширением *.dfm.

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

Рассмотрим организацию исходного текста модуля:

unit MyUnit1;
interface
uses
Unit1, Unit2, Unit3;
const
Pi = 3.14;
type
MyType =. .;
var
var1: MyType;
procedure Proc1;
function Func: MyType;
implementation
uses
Unit4, Unit5, Unit6;
const
…;
type
…;
var
…;
procedure Proc1;
begin
{ Операторы}
…
end;
function Func: MyType;
begin
{Операторы}
…
end;
initialization
{Операторы}
…
finalization
{Операторы}
…
end.

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

unit MyUnit1;

Имена файлов MyUnit1.pas, MyUnit1.dfm должны совпадать с именем, описанным в заголовке модуля MyUnit1. Наличие файла MyUnit1.dfm не является обязательным.

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

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

В необязательном разделе initialization размещаются операторы, которые выполняются сразу после запуска программы.

Раздел finalization не является обязательным, более того, он может присутствовать только в том случае, если в модуле присутствовала секция initialization. В секции размещаются операторы, которые выполняются непосредственно перед завершением программы.

2. ОБЪЕКТЫ И КЛАССЫ В ЯЗЫКЕ OBJECT PASCAL

В обычном языке Pascal существует тип-запись:

type
TmyRecord = record
MyField1: String;
MyField2: Integer;
end;

Тип-запись позволяет описывать структурированные переменные, содержащие несколько значений как одного, так и разных типов. В приведенном примере запись TmyRecord содержит поля MyField1 и MyField2, которые соответственно имеют типы String и Integer.

Тип-класс в Object Pascal по виду близок к записи, но отличается от записи возможностью наследования от других классов, а также возможностью описания методов класса. Классом в Object Pascal называется особый тип записи, который может иметь в своем составе поля, методы и свойства. Такой тип также будем называть объектным типом:

type
TMyObject = class(TObject)
MyField: Integer;
Procedure MyMethod1 (X: Real; var Y: Real);
function MyMethod2: Integer;
end;

В примере описан класс TMyObject, который наследуется от класса Tobject. Понятие "наследования классов" и понятие "свойства" будут подробно рассмотрены далее. Пока можно определить понятие свойства как поле, которое доступно не напрямую, а через посылку сообщений особым методам.

Класс TMyObject имеет поле MyField и методы MyMethod1 и MyMethod2. Нужно заострить внимание на том, что классы могут быть описаны либо в секции интерфейса модуля Interface (под модулем здесь понимается файл с исходным кодом вида Unit), либо на верхнем уровне вложенности секции реализации Implementation. He допускается описание классов внутри процедур и других блоков кода.

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

type
TFirstObject = class;
TSecondObject = class (TObject)
Fist: TFirstObject;
{…}
end;
TFirstObject = class(TObject)
{…}
end;

Код методов описывается ниже по тексту объявлений классов, например:

Procedure TMyObject.MyMethod1(X: Real; var Y: Real);
begin
у:= 5.0 * sin(X);
end;
function TMyObject.MyMethod2: Integer;
begin
{…}
MyMethod2:= MyField + 3;
end;

Для того чтобы использовать новый тип в программе, нужно, как минимум, объявить переменную этого типа, которая называется или переменной объектного типа, или экземпляром класса, или объектом:

var
AMyObject: TMyObject;

Согласно обычному языку Borland Pascal, переменная AMyObject должна содержать в себе весь экземпляр объекта типа TMyObject (код и данные вместе) — статический объект. Но в Delphi все объекты динамические, поэтому, не вдаваясь в подробности, выполним оператор:

{действие по созданию экземпляра объекта}
AMyObject:= TMyObject.Create;

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

var
К: Integer;
{…}
AMyObject.MyMethod1(2.3, Z);
К:= 6 + AMyObject.MyMethod2;

Методы — это процедуры и функции, описанные внутри класса. Как видно, посылка сообщений в Object Pascal близка к вызову процедур языка Pascal, но имени вызываемой процедуры или процедуры-функции предшествует имя конкретного объекта, например: AMyObject.

Опишем два объекта AMyObject, BMyObject одного класса TMyObject:

var
AMyObject,
BMyObject: TmyObject;

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

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

AMyObject.MyMethod1(2.3, Z);
BMyObject.MyMethod1(0.7, Q)

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

Засылка и извлечение значений в поля, согласно нерекомендуемому в Object Pascal прямому доступу, практически не отличается от использования полей записи обычного языка Pascal:

AMyObject.MyField:= 3;
I:= AMyObject.MyField + 5.

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

3. ОБЛАСТИ ВИДИМОСТИ

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

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

 public — общие;

 private — личные;

 protected— защищенные;

 published — опубликованные.

Деление на составные части работает на уровне файлов модулей (Unit в смысле языка Pascal). Если вы нуждаетесь в специальной защите объекта или его части, то для этого необходимо поместить его в отдельный модуль, в котором есть собственные секции interface и implementation.

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

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

Раздел protected комбинирует функциональную нагрузку разделов private и public таким образом, что если вы хотите скрыть внутренние механизмы вашего объекта от конечного пользователя, этот пользователь не сможет в run-time использовать ни одно из объявлений объекта из его protected-области. Но это не помешает разработчику новых компонент использовать эти механизмы в других наследуемых классах, т. е. protected-объявления доступны у любого из наследников вашего класса.

Раздел published оказался необходимым при введении в Object Pascal возможности установки свойств и поведения компонент еще на этапе конструирования форм и самого приложения (design-time) в среде визуальной разработки программ Delphi. Именно published-объявления доступны через Object Inspector, будь это ссылки на свойства или обработчики событий. Во время исполнения приложения раздел объекта published полностью аналогичен public.

Следует отметить тот факт, что при порождении нового класса путем наследования возможен перенос объявлений из одного раздела в другой с единственным ограничением: если вы производите скрытие объявления за счет его переноса в раздел private, в дальнейшем его "вытаскивание" у наследника в более доступный раздел в другом модуле будет уже невозможен. Такое ограничение, к счастью, не распространяется на динамические методы-обработчики сообщений Windows.

Пример описания класса с заданными областями видимости приведен ниже.

4. ИНКАПСУЛЯЦИЯ

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

Работу со свойствами рассмотрим на следующем примере. Пусть мы создали при помощи дизайнера форм Delphi экранную форму Forml с двумя элементами визуальных компонент: Button 1 и Label 1 (рис. 1).

Рис. 1. Экранная форма примера

Кликнем кнопку Button1 и отредактируем исходный текст модуля до следующего текста:

unit testir;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls;
type
TForm1 = class(TForm)
Button1: TButton;
Label1: TLabel;
procedure Button1Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
type
TSomeType = String;
type
TAnObject = class(TObject)
private
FValue: TSomeType;
function GetAProperty: TSomeType;
procedure SetAProperty (ANewValue: TSomeType);
public
property AProperty: TSomeType
read GetAProperty
write SetAProperty;
end;
var
Form1: TForm1;
AnObject: TAnObject;
implementation
{$R *.DFM}
procedure TForm1.ButtonlClick(Sender: TObject);
begin
AnObject:= TAnObject.Create;
AnObject.AProperty:= 'Привет!';
Label1.Caption:= AnObject.AProperty;
end;
procedure TAnObject.SetAProperty(
ANewValue: TSomeType);
begin
FValue:= ANewValue; {Засылка значения в поле}
end;
function TAnObject.GetAProperty: TSomeType;
begin
GetAProperty:= FValue; {Чтение значения из поля}
end;
end.

Сохраним проект (Save Project As). При сохранении проекта укажем новое имя модуля — testir и новое имя проекта — PrTestir. Рассмотрим текст получившегося файла проекта (пункты меню View и далее Project Source):

program PrTestir;
uses
Forms,
testir in 'testir.pas' {Form1};
{$R *.RES}
begin
Application.Initialize;
Application.CreateForm(TForm1, Form1);
Application.Run;
end.

Данный файл содержит текст основной программы PrTestir. К основной программе подключаются модуль Forms (для работы с формой) и исходный код модуля testir. Три исполняемых оператора основной программы последовательно организуют новый вычислительный процесс выполнения написанной программы PrTestir, создадут объект формы Form1, осуществят запуск программы на выполнение (Run).

В набранном примере текст модуля содержит сгенерированный текст объявления объектного типа Tform1. В типе содержатся указания на агрегацию в данном классе объекта кнопки Button1: Tbutton и объекта Label1: Tlabel. Благодаря агрегации экземпляры объектов кнопки и надписи будут создаваться одновременно с созданием экземпляра объекта формы, в результате чего как бы получится совместно работающий с кнопкой и надписью объект формы. В типе Tform1 Delphi по двойному щелчку мыши по кнопке <Button1> сгенерировала прототип вызова метода:

procedure Button1Click(Sender: TObject).

Также Delphi автоматически сгенерировала переменную объектного типа

var
Form1: TForm1;

и в секции реализации вставила текст "пустой" процедуры Button1Click отработки действий по нажатию кнопки Button1.

Рассмотрим элементы, добавленные нами в текст модуля по реализации инкапсуляции. Итак, нами был набран текст описания класса TAnObject и переменная данного объектного типа AnObject:

type
TAnObject = class(TObject) private
FValue: TSomeType;
function GetAProperty: TSomeType;
procedure SetAProperty (ANewValue: TSomeType);
public
property AProperty: TSomeType
read GetAProperty
write SetAProperty;
end;
var
AnObject: TanObject.

Обычно свойство (property) определяется тремя своими элементами: полем и двумя методами, которые осуществляют его запись/чтение:

private
FValue: TSomeType;
function GetAProperty: TSomeType;
procedure SetAProperty (ANewValue: TSomeType);
public
property AProperty: TSomeType
read GetAProperty
write SetAProperty;
…
procedure TAnObject.SetAProperty(ANewValue: TSomeType);
begin
FValue:= ANewValue; {Засылка значения в поле}
end;
function TAnObject.GetAProperty: TSomeType;
begin
GetAProperty:= FValue; {Чтение значения из поля}
end;

В данном примере свойство Aproperty выполняет такую же функцию, какую в предшествующем примере выполняло поле MyField. Доступ к значению свойства Aproperty осуществляется через вызовы методов GetAProperty и SetAProperty. Однако в обращении к этим методам в явном виде нет необходимости (в рассматриваемом примере они даже защищены — protected), достаточно написать:

AnObject.AProperty:=…;
…:= AnObject.Aproperty;

и компилятор оттранслирует эти операторы в вызовы методов.

Рассмотрим три оператора, вписанные в текст "пустой" процедуры (метод) Button1Click:

AnObject:= TAnObject.Create;
AnObject.AProperty:= 'Привет!';
Label1.Caption:= AnObject.AProperty;

Первый оператор создает экземпляр объекта. Второй оператор в недоступное по интерфейсу (protected) поле Fvalue засылает при помощи недоступной по интерфейсу (protected) процедуры AnObject.SetAProperty текст "Привет!". Третий оператор при помощи недоступной по интерфейсу (protected) процедуры АпОЬject.GetAProperty считывает данные из недоступного по интерфейсу поля Fvalue и засылает их в свойство Caption объекта надписи Label1.

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

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

Рассмотрим следующую конструкцию:

type
TPropObject = class(TObject)
FValue: TSomeType;
procedure DoSomething;
procedure Correct(AValue: Integer);
procedure SetValue(NewValue: Integer);
procedure AValue: Integer read Fvalue
write SetValue;
end;
…
procedure TPropObject.SetValue(NewValue: Integer);
begin
if (NewValue <> FValue) and Correct (NewValue)
then
FValue:= NewValue; {Засылка значения в поле}
DoSomething;
end;

В этом примере чтение значения свойства AValue означает просто чтение поля FValue. Зато при присвоении ему значения внутри метода SetValue вызывается сразу два метода.

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

type
TAnObject = class(TObject)
property AProperty: TSomeType read GetValue;
end;

В этом примере вне объекта значение свойства можно лишь прочитать. Попытка присвоить значение Aproperty вызовет ошибку компиляции.

5. ОБЪЕКТЫ И ИХ ЖИЗНЕННЫЙ ЦИКЛ

Как создаются и уничтожаются объекты? В Object Pascal экземпляры объектов могут быть только динамическими! Это означает, что в приведенном в начале раздела фрагменте переменная AMyObject хотя и выглядит как статическая переменная языка Pascal, на самом деле является указателем, содержащим адрес объекта. Любая переменная объектного типа и есть указатель (указатель — переменная, содержащая значение адреса оперативной памяти).

Память под конкретные объекты (динамические экземпляры классов) выделяется диспетчером памяти в периоде выполнения программы в особой heap-области, где должно еще быть свободное место для размещения новых объектов. Heap — "куча мусора". Диспетчер памяти может как размещать в heap-области новые объекты, так и удалять уже ненужные, освобождая память под все новые объекты. Как раз при размещении объекта в памяти инициализируется значение переменной объектного типа адресом объекта. При удалении объекта переменная объектного типа инициализируется значением nil (пустой указатель) — нет объекта в памяти. При размещении нового объекта в памяти может оказаться, что общая свободная память имеет большой объем, но любой из освободившихся участков памяти, занимаемых уже удаленными объектами, оказывается меньше объема нового большого объекта. Для избежания такой ситуации при использовании объектных программ устанавливают в ЭВМ оперативную память заведомо большого объема. Новый экземпляр объекта создается особым методом — конструктором, а уничтожается специальным методом — деструктором:

AMyObject:= TMyObject.Create; {действия с созданным объектом}
…
AMyObject.Destroy; {уничтожение объекта}

В Object Pascal конструкторов у класса может быть несколько. Общепринято называть конструктор Create. Типичное название деструктора — Destroy. Рекомендуется использовать для уничтожения экземпляра объекта метод Free, который первоначально проверяет указатель (не равен ли он nil) и затем уж вызывают Destroy.

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

constructor TmyObject.Create;
begin
inherited Create;
…
end;

Метод Create объекта MyObject типа TMyObject унаследован от класса предка TObject.

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

Кто создает и уничтожает формы? Это делает приложение (глобальный объект с именем Application). В файле проекта (.DPR) можно увидеть вызов функции CreateForm, предназначенный для этой цели. Что же касается объектов, создаваемых динамически (во время выполнения приложения), то здесь нужен явный вызов конструктора.

6. НАСЛЕДОВАНИЕ

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

TNewObject = class(TOldObject);

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

В Object Pascal все классы являются потомками класса TObject. Поэтому если строится дочерний класс прямо от TObject, то в определении TOject можно не упоминать. Следующие два выражения одинаково верны:

TMyObject = class(TObject);
TMyObject = class;

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

Приведем объявление базового для всех объектных типов класса TObject:

TObject = class
constructor Create;
destructor Destroy; virtual;
procedure Free;
class function Newlnstance: TObject; virtual;
procedure Freelnstance; virtual;
class procedure Initlnstance(Instance: Pointer):
TObject;
function ClassType: TClass;
class function ClassName: string;
class function ClassParent: TClass;
class function ClassInfo: Pointer;
class function InstanceSize: Word;
class function InheritsFrom(AClass: TClass):
Boolean;
procedure DefaultHandler(var Message); virtual;
procedure Dispatch(var Message);
class function MethodAddress(const Name: string):
Pointer;
class function MethodName(Address: Pointer):
string;
function FieldAddress(const Name: string):
Pointer;
end;

Такая архитектура возможна только при наличии механизма поддержки информации о типах — RTTI (RunTime Type Information). Основой такого механизма является внутренняя структура классов и, в частности, возможность доступа к ней за счет использования методов классов, описываемых конструкцией class function…

Унаследованные от предка поля и методы доступны в дочернем классе; если имеет место совпадение имен методов, то эти методы перекрываются.

По тому, какие действия происходят при вызове, методы делятся на группы:

• статические (static);

• виртуальные (virtual);

• динамические (dynamic);

• абстрактные (abstract).

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

type
T1stObj = class
I: Real;
procedure SetData(Avalue: Real);
end;
T2ndObj = class(T1stObj)
I: Integer;
procedure SetData(Avalue: Integer);
end;
…
procedure T1stObj.SetData;
begin
i: = v;
end;
procedure T2nd0bj.SetData;
begin
i:= 0;
inherited SetData(0.99);
end;

В этом примере разные методы с именем SetData присваивают значения разным полям с именем i. Перекрытое поле предка недоступно в потомке. В отличие от поля внутри других методов перекрытый метод доступен при указании зарезервированного слова inherited. Методы объектов по умолчанию являются статическими — их адрес определяется еще на стадии компиляции проекта. Они вызываются быстрее всего.

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

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

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

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

Когда компилятор встречает обращение к виртуальному методу, он подставляет вместо обращения к конкретному адресу код, который обращается к специальной таблице и извлекает оттуда нужный адрес. Эта таблица называется таблицей виртуальных методов (Virtual Method Table, VMT), и она есть для каждого объектного типа. В ней хранятся адреса всех виртуальных методов класса независимо от того, унаследованы ли они от предка или перекрыты. Отсюда и достоинства, и недостатки виртуальных методов: они вызываются сравнительно быстро (но медленнее статических), однако для хранения указателей на них требуется большое количество памяти.

Динамические методы вызываются медленнее, но позволяют более экономно расходовать память. Каждому динамическому методу системой присваивается уникальный индекс. В таблице динамических методов (Dynamic Method Table, DMT) класса хранятся индексы и адреса только тех динамических методов, которые описаны в данном классе (базовая информация по обработке динамических методов содержится в модуле x: delphisourcertlsysdmth.asm). При вызове динамического метода происходит поиск в этой таблице. В случае неудачи просматриваются все классы-предки в порядке иерархии и, наконец, TObject, где имеется стандартный обработчик вызова динамических методов. Экономия памяти налицо.

Для перекрытия и виртуальных, и динамических методов служит новая директива override, с помощью которой (и только с ней!) можно переопределять оба этих типа методов:

type
TFirstClass = class
FMyField1: Integer;
FMyField2: Longlnt;
procedure StatMethod1;
procedure VirtMethod1; virtual;
procedure VirtMethod2; virtual;
procedure DynaMethod1; dynamic;
procedure DynaMethod2; dynamic;
end;
TSecondClass = class(TFirstClass)
procedure StatMethod;
procedure VirtMethod; override;
procedure StatMethod; override;
end;
var
Obj2: TFirstClass;
Obj1: TSecondClass;

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

В Object Pascal абстрактными называются методы, которые определены в классе, но не содержат никаких действий, никогда не вызываются и должны быть переопределены в потомках класса. Абстрактными могут быть только виртуальные и динамические методы. Для этого используется директива abstract, указываемая при описании метода:

procedure NeverCallMe; virtual; abstract;

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

7. ПОЛИМОРФИЗМ

Рассмотрим пример, которой поясняет, для чего нужно использование абстрактных методов. Пусть у нас имеются некое обобщенное поле для хранения данных — класс TField и три его потомка — для хранения строк, целых и вещественных чисел. В данном случае класс Tfield не используется сам по себе; его основное предназначение — быть родоначальником иерархии конкретных классов — "полей" и дать возможность абстрагироваться от частностей. Хотя параметр у ShowData и описан как TField, но если поместить туда объект этого класса, произойдет ошибка вызова абстрактного метода:

type
TField = class
function GetData: string; virtual; abstract;
end;
TStringField = class(TField)
Data: string;
function GetData: string; override;
end;
TIntegerField = class(TField)
Data: Integer;
function GetData: string; override;
end;
TExtendedField = class(TField)
Data: Integer;
function GetData: string; override;
end;
function TStringField.GetData;
begin
GetData:= Data;
end;
function TIntegerField.GetData;
begin
GetData:= IntToStr(Data);
end;
function TExtendedField.GetData;
begin
GetData:= IntToStrF(Data, ffFixed, 7, 2);
end;
…
procedure ShowData(AField: TField);
begin
Form1.Label1.Caption:= AField.GetData;
end;

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

Правила контроля соответствия типов (typecasting) языка Pascal говорят о том, что объекту как указателю на экземпляр объектного типа может быть присвоен адрес любого экземпляра любого из дочерних типов. В процедуре ShowData параметр описан как TField. Это значит, что в нее можно передавать объекты классов и TStringField, и TIntegerField, и TExtendedField, и любого другого потомка TField.

Но какой (точнее, чей) метод GetData при этом будет вызван? Тот, который соответствует классу фактически переданного объекта. Этот принцип называется полиморфизмом, и он, пожалуй, представляет собой наиболее важный "козырь" ООП. Допустим, имеется дело с некоторой совокупностью явлений или процессов. Чтобы смоделировать их средствами ООП, нужно выделить их самые общие, типовые черты. Те из них, которые не изменяют своего содержания, должны быть реализованы в виде статических методов. Те же, которые варьируют при переходе от общего к частному, лучше облечь в форму виртуальных методов. Основные "родовые" черты (методы) нужно описать в классе-предке и затем перекрыть их в классах-потомках. В предыдущем примере программисту, пишущему процедуру вроде ShowData, важно лишь одно: то, что любой объект, переданный в нее, является потомком TField, и он умеет сообщить о значении своих данных (выполнив метод GetData).

Если такую процедуру скомпилировать и поместить в динамическую библиотеку, то эту библиотеку можно будет раз и навсегда использовать без изменений, хотя будут появляться и новые, неизвестные в момент ее создания классы-потомки TField!

Наглядный пример использования полиморфизма дает сама Delphi. В ней имеется класс TComponent, на уровне которого сосредоточены определенные "правила" того, как взаимодействовать со средой разработки и с другими компонентами. Следуя этим правилам, можно порождать от TComponent свои компоненты, настраивая Delphi на решение специальных задач.

8. ОБРАБОТКА СООБЩЕНИЙ

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

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

type
TMyControl = class(TWinControl)
procedure WMSize(var Message: TWMSize);
message WM_SIZE;
end;
type
TMyOtherControl = class(TMyControl)
procedure Resize(var Info);
message WM_SIZE;
end;

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

Необходимости изобретать собственные структуры, по-своему интерпретирующие содержание того или иного сообщения, нет: для большинства сообщений Windows типы уже описаны в модуле MESSAGES.

В обработчиках сообщений (и только в них) можно вызвать метод-предок, просто указав ключевое слово inherited, без указания его имени и преобразования типа параметров: предок будет найден по индексу. Следует напомнить, что система обработки сообщений встроена в Object Pascal на уровне модели объектов, и самый общий обработчик — метод DefaultHandler — описан в классе TObject.

9. СОБЫТИЯ И ДЕЛЕГИРОВАНИЕ

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

Рассмотрим, как реализованы события на уровне языка Object Pascal. События — это свойства процедурного типа, предназначенные для создания пользовательской реакции на те или иные входные воздействия:

property OnMyEvent: TMyEvent read FonMyEvent
write FonMyEvent;

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

Application.OnActive:= MyActivatingMethod;

Это означает, что при каждой активизации Application (так называется объект, соответствующий работающему приложению) будет вызван метод-обработчик MyActivatingMethod.

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

if Assigned(FonMyEvent)
then
FonMyEvent(Self);

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

TNotifyEvent = procedure(Sender: TObject) of object;

Тип метода, предназначенный для извещения о нажатии клавиши, предусматривает передачу программисту кода этой клавиши, а передвижение мыши — ее координат и т. п.

Все события в Delphi принято именовать с "On": OnCreate, OnMouseMove, OnPaint и т. д. Щелкнув в Инспекторе объектов на странице Events в поле любого события, автоматически получается заготовка метода нужного типа. При этом его имя будет состоять из имени текущего компонента и имени события (без "On"), а относиться он будет к текущей форме. Пусть, например, на форме Form1 есть текст Label1. Тогда для обработки щелчка мышью на нем (событие OnClick) будет создан метод Tform1. Label1Click.

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

Object.OnMouseMove:= Object2.OnMouseMove;

Но какой механизм позволяет подменять обработчики, ведь это не просто процедуры, а методы? Здесь как нельзя кстати приходится введенное в Object Pascal понятие указателя на метод. Помимо явно описанных параметров методу передается еще и указатель на вызвавший его экземпляр (Self). Вы можете описать тип процедуры, которая будет совместима по присваиванию с методом (т. е. предусматривать получение Self). Для этого в ее описание нужно добавить зарезервированные слова of Object. Указатель на метод — это указатель на такую процедуру:

type
TmyEvent = procedure(Sender: TObject;
var Avalue: Integer) of object;
T1stObject = class;
FOnMyEvent: TMyEvent;
property OnMyEvent: TMyEvent read FonMyEvent
write FonMyEvent;
end;
T2ndObject = class;
procedure SetValue1(Sender: TObject;
var Avalue: Integer);
procedure SetValue2(Sender: TObject;
var Avalue: Integer);
end;
…
var
Obj1: T1stObject;
Obj2: T2ndObject;
begin
Obj1:= T1stObject.Create;
Obj2:= T2ndtObject.Create;
Obj1.OnMyEvent:= Obj2.SetValue1;
Obj2.OnMyEvent:= Obj2.SetValue2;
…
end;

Как в этом примере, так и повсюду в Delphi за свойствами-событиями стоят поля, являющиеся указателями на метод. Таким образом, при делегировании можно присваивать методы других классов. Здесь обработчиком события OnMyEvent объекта Obj1 по очереди выступают методы SetValue1 и SetValue2 объекта Obj2.

10. ФУНКЦИИ КЛАССА

В Object Pascal имеется возможность определения полей процедурного типа. Очевидно, что в теле функций, привязываемых к этим полям, разработчику необходим доступ к другим полям объекта, методам и т. п. Возможность такого доступа базируется на передаче в эти функции неявного, но доступного в их коде параметра, автоматически принимающего значение поля объекта Self. Такие функции называются функциями классов. Для объявления функций классов необходимо использовать специальную конструкцию function … of object.

11. ПРИВЕДЕНИЕ ТИПОВ

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

В языке Pascal имеется механизм явного приведения типов.

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

Выражение, представленное в следующем примере, возвращает True, если переменная AnObject ссылается на образец объектного типа TMyClass или одного из его потомков.

AnObject is TmyClass

Сама по себе операция is не является операцией задания типа. В ней лишь проверяется совместимость объектных типов. Для корректного приведения типа объекта применяется операция as:

With AnObject as TmyClass do…

Возможен и такой способ приведения типа без явного указания as.

With TMyClass(AnObject)do…

В программах перед операцией as проверяют совместимость типов с помощью операции is. Если типы несовместимы, запускается обработчик исключительной ситуации EinvalidCast.

Таким образом, в конструкции as операция явного приведения типа оказывается заключенной в безопасную оболочку:

If AnObject is TobjectType then
with TobjectType(AnObject) do …
else
raise EinvalidCast.Create('Неправильное приведение типа');

12. ОБЪЕКТНАЯ ССЫЛКА

Delphi позволяет создать специальный описатель объектного типа (именно на тип, а не на экземпляр!), известный как object reference — объектная ссылка.

Объектные ссылки используются в следующих случаях:

— тип создаваемого объекта не известен на этапе компиляции;

— необходим вызов метода класса, чей тип не известен на этапе компиляции;

— в качестве правого операнда в операциях проверки и приведения типов с использованием is и as.

Объектная ссылка определяется с использованием конструкции class of… Приведем пример объявления и использования class reference:

type
TMyObject = class (TObject)
MyField: TMyObject;
constructor Create;
end;
TObjectRef = class of TObject;
…
var
ObjectRef: TObjectRef;
s: string;
begin
ObjectRef:=TMyObject; {присваиваем тип, а не экземпляр!}
s:=ObjectRef.ClassName; {строка s содержит 'TMyObject'}
end;

Таким образом, в Delphi определена специальная ссылка TClass, совместимая по присваиванию с любым наследником TObject. Аналогично объявлены классы: TPersistentClass и ТСотроnentClass.

13. СТРУКТУРНАЯ ОБРАБОТКА ИСКЛЮЧИТЕЛЬНЫХ СИТУАЦИЙ

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

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

Структурная обработка исключительных ситуаций — это программный механизм, позволяющий программисту при возникновении ошибки (исключительной ситуации — exception) связаться с кодом программы, подготовленным для обработки такой ошибки. В Delphi система называется структурной, поскольку обработка ошибок определяется областью "защищенного" кода. Такие области могут быть вложенными. Выполнение программы не может перейти на произвольный участок кода. Выполнение программы может перейти только на обработчик исключительной ситуации активной программы.

Модель исключительных ситуаций в Object Pascal является не-возобновляемой (non-resumable). При возникновении исключительной ситуации вы уже не сможете вернуться в точку, где она возникла, для продолжения выполнения программы (это позволяет сделать лишь возобновляемая (resumable) модель).

Для обработки исключительных ситуаций в язык Object Pascal добавлено новое ключевое слово "try", которое используется для обозначения первой части защищенного участка кода. Существуют два типа защищенных участков:

1) try..except;

2) try..finally.

Первый тип используется для обработки исключительных ситуаций. Его синтаксис:

try
Statement1;
Statement2;
…
except
on Exception1 do Statement;
on Exception2 do Statement;
…
else
Statements; {default exception-handler}
end;

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

try
Statement1;
Statement2;
finally
Statements; {These statements always execute}
end;

Оглавление книги