Тема 3: Введение в объектно-ориентированное программирование.

1. Понятие класса

2. Понятие объекта

3. Создание и уничтожение объектов

4. Свойства

5. События

1.Понятие класса.

Классом в Delphi называется особый тип, который может иметь в своем составе поля, методы и свойства. Такой тип также называют объектным типом.

type

tMyClass=class(tObject)

fMyFiled: integer;

function MyMethod: integer;

end;

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

2.Понятие объекта

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

var aMyObject: tMyClass;

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

3.Создание и уничтожение объектов

В отличие от С++ и Turbo Pascal в Delphi объекты могут быть только динамическими!!!. Это означает, что в приведенном выше примере переменная aMyObject на самом деле является указателем, содержащем адрес объекта.

Объект создается конструктором и уничтожается деструктором.

aMyObject := tMyClass.Create;

//

// действия с созданным объектом

//

aMyObject.Destroy;

Следует обратить внимание на то, что для создания объекта aMyObject вызывается метод класса tMyClass.Create. Конструктор класса (и ряд других методов) успешно работает и до создания объекта. Однако большинство обычных методов (в частности все виртуальные и динамические методы). Вызывать до инициализации объекта не следует.

В Delphi конструкторов у класса может быть несколько. Общепринято называть конструктор Create, в отличие от Turbo Pascal, где конструкторы назывались Init, и С++, в котором имя конструктора совпадает с именем класса. Типичное название деструктора - Destroy.

type

tMyClass=class(tObject)

fMyFiled: integer;

Constructor Create;

Destructor Destroy;

function MyMethod: integer;

end;

Для уничтожения объекта в Delphi рекомендуется использовать не деструктор, а метод Free, который первоначально проверяет указатель, и только затем вызывает деструктор Destroy:

procedure tObject.Free;

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

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

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

constructor tMyClass.Create;

Begin

inherited Create;

// Код инициализации tMyClass

End;

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

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

4.Свойства

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

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

type

tMyClass=class(tObject)

function GetaProperty: tSomeType;

procedure SetaProperty(Value: tSomeType);

property aProperty: tSomeType read GetaProperty

write SetaProperty;

end;

В данном примере доступ к значению свойства aProperty осуществляется через вызовы методов GetaProperty и SetaProperty, однако в обращении к этим методам в явном виде нет необходимости: достаточно написать

aMyObject.aProperty:=aValue;

aVarable:= aMyObject.aProperty;

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

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

tPropClass=class

fValue: tSomeType;

procedure SetValue(aValue: tSomeType);

property Value:tSomeType read fValue write SetValue;

End;

В этом примере поле fValue модифицируется при помощи метода SetValue, а читается напрямую.

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

tReadOnlyClass=class

property NotChanged:tSomeType read GetNotChanged;

End;

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

Свойствам можно присваивать значения по умолчанию. Для этого служит ключевое слово default:

Property Visible:boolean read fVisible write SetVisible default TRUE;

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

Свойство может быть и векторным. В этом случае оно выглядит как массив:

Property Points[index:integer]:tPoint read GetPoint write SetPoint;

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

function GetPoint(index:integer):tPoint;

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

procedure SetPoint(index:integer; Value:tPoint);

У векторных свойств есть еще одна важная особенность: некоторые классы в Delphi (списки tList, наборы строк tStrings и т.д.) “построены” вокруг одного основного векторного свойства. Основной метод такого класса дает доступ к элементам некоторого массива, а все основные методы являются как бы вспомогательными. Для упрощения работы с объектами подобного класса можно описать подобное свойство с ключевым словом default:

type tMyList=class

property list[Index:integer]:string read Getlist write Setlist; default;

end;

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

var MyList:tMyList

Begin

MyList.list[1]:=’First’; {Первый способ}

MyList.[2]:=’Second’; {Первый способ}

End;

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

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

5.События

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

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

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

Property OnMyEvent: tMyEvent read FMyEvent write FMyEvent;

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

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

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

tNotifyEvent = procedure(Sender:tObject) of object;

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

Имя события в Delphi начинается с префикса On: OnClick, OnCreate, OnMouseDown и т.д. Имена методов - обработчиков событий состоят из имени объекта, генерирующего событие, и корня имени события: OkButtonClick. Дважды щелкнув мышью в инспекторе объектов на странице Events в поле напротив любого события, вы получите скелетный код (заготовку) этого события.

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

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

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

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

If Sender is tMenuItem then ...

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

Ниже приведены названия некоторых, наиболее употребительных событий Delphi:

Событие - Тип обработчика - Когда возникает

OnClick - TNotifyEvent - При нажатии левой клавиши мыши

OnActivate - TnotifyEvent - После передачи объекту фокуса

OnCreate - TnotifyEvent - После создание объекта

OnDestroy - TnotifyEvent - Перед уничтожением объекта

OnDeactivate - TnotifyEvent - Перед уходом фокуса из объекта

OnKeyPress - TkeyPressEvent - При нажатии клавиши

OnMouseDown - TmouseEvent - При нажатии клавиши мыши

OnMouseMove - TmouseMoveEvent - При движении мыши над объектом

OnMouseUp - TmouseEvent - При отпускании клавиши мыши

а также их типы:

Тип

Описание

TnotifyEvent

type TnotifyEvent = procedure (Sender: TObject) of object;

TkeyPressEvent

type TkeyPressEvent = procedure (Sender: TObject; var Key: Char) of object;

TmouseEvent

TmouseEvent = procedure (Sender: TObject; Button: TmouseButton; Shift: TShiftState; X, Y: Integer) of object;

TmouseMoveEvent

TmouseMoveEvent = procedure(Sender: TObject; Shift: TShiftState; X, Y: Integer) of object;

Стандартные события описаны в модуле Classes.