Программирование на Delphi
Этот курс посвящен среде разработки Delphi фирмы Borland (известной также как Inprise), которая на протяжении многих лет успешно выдерживает (и выигрывает!) жесткую конкуренцию с другими средами программирования. Концепция Delphi1 была реализована в конце 1994 года, когда вышла первая версия среды разработки. В основу этого программного продукта легли концепции объектно-ориентированного программирования (ООП) на базе языка Object Pascal и визуального подхода к построению приложений. После выхода Delphi 1 все компьютерные издания писали об этой среде, как об “убийце Visual Basic”. Появление Delphi 2 (32-разрядной) ознаменовало новую эпоху, - появился доступ к возможностям программных интерфейсов Windows NT и Windows 95, протоколам OLE. Delphi 2 стала средством разработки полноценных приложений клиент/сервер. Вскоре Delphi 3 предоставила разработчикам средства создания распределенных многоуровневых приложений и полноценный инструментарий проектирования приложений для Internet и intranet. Появилась полноценная поддержка COM - модели объектов, ставшей краеугольным камнем современного программирования. Четвертая версия Delphi позволяет полностью интегрировать ваши разработки с объектами COM. Поддержка архитектуры CORBA (Common Object Request Broker Architecture) открывает перед приложениями, созданными в Delphi для платформы Wintel (Windows + Intel), мир других операционных систем (UNIX, OS/2, WMS). Общаться с крупными корпоративными СУБД стало также просто, как и со старым добрым Paradox. Вы можете использовать в своей работе любые уровни межзадачного взаимодействия: от простейшего на уровне сокетов, до связи с такими перспективными инструментами, как Microsoft Transaction Server. Delphi представляет следующие новые свойства и усовершенствования:
Delphi - это комбинация нескольких важнейших технологий:
Компилятор, встроенный в Delphi, обеспечивает высокую производительность, необходимую для построения приложений в архитектуре “клиент-сервер”. Он предлагает легкость разработки и быстрое время проверки готового программного блока, характерного для языков четвертого поколения (4GL) и в то же время обеспечивает качество кода, характерного для компилятора 3GL. Кроме того, Delphi обеспечивает быструю разработку без необходимости писать вставки на Си или ручного написания кода (хотя это возможно). В процессе построения приложения разработчик выбирает из палитры компонент готовые компоненты как художник, делающий крупные мазки кистью. Еще до компиляции он видит результаты своей работы - после подключения к источнику данных их можно видеть отображенными на форме, можно перемещаться по данным, представлять их в том или ином виде. В этом смысле проектирование в Delphi мало чем отличается от проектирования в интерпретирующей среде, однако после выполнения компиляции мы получаем код, который исполняется в 10-20 раз быстрее, чем то же самое, сделанное при помощи интерпретатора. Кроме того, компилятор компилятору рознь, в Delphi компиляция производится непосредственно в родной машинный код, в то время как существуют компиляторы, превращающие программу в так называемый p-код, который затем интерпретируется виртуальной p-машиной. Это не может не сказаться на фактическом быстродействии готового приложения. Объектно-ориентированная модель программных компонент. Основной упор этой модели в Delphi делается на максимальном реиспользовании кода. Это позволяет разработчикам строить приложения весьма быстро из заранее подготовленных объектов, а также дает им возможность создавать свои собственные объекты для среды Delphi. Никаких ограничений по типам объектов, которые могут создавать разработчики, не существует. Действительно, все в Delphi написано на нем же, поэтому разработчики имеют доступ к тем же объектам и инструментам, которые использовались для создания среды разработки. В результате нет никакой разницы между объектами, поставляемыми Borland или третьими фирмами, и объектами, которые вы можете создать. В стандартную поставку Delphi входят основные объекты, которые образуют удачно подобранную иерархию базовых классов. Но если возникнет необходимость в решении какой-то специфической проблемы на Delphi, советуем, прежде чем попытаться начинать решать проблему “с нуля”, просмотреть список свободно распространяемых или коммерческих компонент, разработанных третьими фирмами, количество этих компонент в настоящее время составляет несколько тысяч. Событийная модель в Windows всегда была сложна для понимания и отладки. Но именно разработка интерфейса в Delphi является самой простой задачей для программиста. Объекты БД в Delphi основаны на SQL и включают в себя полную мощь Borland Database Engine. В состав Delphi также включен Borland SQL Link, поэтому доступ к СУБД Oracle, Sybase, Informix и InterBase происходит с высокой эффективностью. Кроме того, Delphi включает в себя локальный сервер Interbase для того, чтобы можно было разработать расширяемые на любые внешние SQL-сервера приложения в офлайновом режиме. азработчик в среде Delphi, проектирующий информационную систему для локальной машины (к примеру, небольшую систему учета медицинских карточек для одного компьютера), может использовать для хранения информации файлы формата .dbf (как в dBase или Clipper) или .db (Paradox). Если же он будет использовать локальный InterBase for Windows (это локальный SQL-сервер, входящий в поставку), то его приложение безо всяких изменений будет работать и в составе большой системы с архитектурой клиент-сервер. Вот она - масштабируемость на практике - одно и то же приложение можно использовать как для локального, так и для более серьезного клиент-серверного вариантов. 1. Основы объектно-ориентированного программирования Понятие класса.
Классом
в Delphi называется
особый тип,
который может
иметь в своем
составе поля,
методы и свойства.
Такой тип также
называют объектным
типом. Поля класса аналогичны полям записи. Это - данные, уникальные в программе для каждого созданного в программе экземпляра класса. Описанный выше класс tMyClass имеет одно поле - fMyFiled. В отличие от полей, методы у двух экземпляров одного класса общие. Методы - это процедуры и функции, описанные внутри класса, и предназначенные для операций над его полями. В состав класса входит указатель на специальную таблицу - таблицу виртуальных методов (VMT), в которой содержится вся информация, необходимая для вызова методов. От обычных процедур и функций методы отличаются тем, что при вызове в них передается указатель на экземпляр класса, который их вызвал. Поэтому обрабатываться будут поля именно того объекта, который вызвал метод. Внутри методов указатель на вызвавший их объект доступен через зарезервированное слово Self. Свойством класса называется совокупность поля и методов чтения/записи, обеспечивающих доступ к этому полю. При этом само поле декларируется как private (доступно только внутри данного класса), и доступ к нему возможен только посредством соответствующих методов. Подробнее свойства будут обсуждаться ниже. Понятие объекта
Чтобы
использовать
новый тип в
программе,
нужно, как
минимум, определить
переменную
этого типа.
Переменная
объектного
типа называется
экземпляром
типа или объектом:
До введения понятия “класс” в языке Pascal существовала двусмысленность определения “объект”, который мог обозначать и тип, и переменную этого типа. Теперь существует четкая граница: класс - это описание, объект - то, что создано в соответствии с этим описанием. Создание и уничтожение объектов В отличие от С++ и Turbo Pascal в Delphi объекты могут быть только динамическими!!!. Это означает, что в приведенном выше примере переменная aMyObject на самом деле является указателем, содержащем адрес объекта.
Объект
создается
конструктором
и уничтожается
деструктором.
Следует обратить внимание на то, что для создания объекта aMyObject вызывается метод класса tMyClass.Create. Конструктор класса (и ряд других методов) успешно работает и до создания объекта. Однако большинство обычных методов (в частности все виртуальные и динамические методы). Вызывать до инициализации объекта не следует.
В Delphi
конструкторов
у класса может
быть несколько.
Общепринято
называть
конструктор
Create, в отличие
от Turbo Pascal, где конструкторы
назывались
Init, и С++, в котором
имя конструктора
совпадает с
именем класса.
Типичное название
деструктора
- Destroy.
Для
уничтожения
объекта в Delphi
рекомендуется
использовать
не деструктор,
а метод Free, который
первоначально
проверяет
указатель, и
только затем
вызывает
деструктор
Destroy: До передачи управления телу конструктора происходит собственно создание объекта: под него отводится память, значения всех полей обнуляются. Далее выполняется код конструктора, написанный программистом для инициализации объектов данного класса. Таким образом, несмотря на то, что синтаксис конструктора схож с вызовом процедуры (отсутствует возвращаемое значение), на самом деле конструктор - это функция, возвращающая созданный и проинициализированный объект. Примечание. Конструктор создает новый объект только в том случае, если перед его именем указано имя класса. Если указать имя уже существующего объекта, он поведет себя по-другому: не создаст новый объект, а только выполнит код, содержащийся в теле конструктора.
Чтобы
правильно
проинициализировать
в создаваемом
объекте поля,
относящиеся
к классу - предку,
нужно сразу
же при входе
в конструктор
вызвать конструктор
предка при
помощи зарезервированного
слова inherited: Как правило, в коде программ, написанных на Delphi, практически н встречается вызовов конструкторов и деструкторов. Дело в том, что любой компонент, попавший при визуальном проектировании в приложение из палитры компонентов, включается в определенную иерархию. Эта иерархия замыкается на форме (класс tForm): для всех ее составных частей конструкторы и деструкторы вызываются автоматически, незримо для программиста. Кто создает и уничтожает формы? Это делает приложение (объект с именем Application). В файле проекта (с расширением DPR) вы можете увидеть вызовы метода Application.CreateForm, предназначенного для этой цели. Что касается объектов, создаваемых динамически (во время выполнения программы), то здесь нужен явный вызов конструктора и метода Free. Свойства Как известно, существует три основных принципа, составляющих суть объектно-ориентированного программирования: инкапсуляция, наследование и полиморфизм. Классическое правило объектно-ориентированного программирования утверждает, что для обеспечения надежности нежелателен прямой доступ к полям объекта: чтение и изменение их содержимого должно осуществляться посредством вызова соответствующих методов. Это правило называется инкапсуляцией (сокрытие данных). В старых реализациях ООП (например в Turbo Pascal) эта мысль внедрялась только посредством призывов и примеров в документации; в Delphi есть соответствующая конструкция. Пользователь объекта в Delphi может быть полностью отгорожен от полей объекта при помощи свойств.
Обычно
свойство
определяется
тремя элементами:
полем и двумя
методами
осуществляющими
его чтение/запись:
В данном
примере доступ
к значению
свойства aProperty
осуществляется
через вызовы
методов GetaProperty и
SetaProperty, однако в
обращении к
этим методам
в явном виде
нет необходимости:
достаточно
написать
и Delphi откомпилирует эти операторы в вызовы соответствующих методов. То есть внешне свойство выглядит в точности как обычное поле, но за всяким обращением к нему могут стоять вызовы необходимых программисту методов. Например, если есть объект, представляющий собой квадрат на экране, и его свойству “цвет” присваивается значение “белый”, то произойдет немедленная прорисовка, приводящая реальный цвет на экране в соответствие значению свойства.
В методах,
устанавливающих
значения свойства,
может производиться
проверка значения
на попадание
в заданный
диапазон значений
и вызов других
процедур зависящих
от вносимых
изменений.
Если же потребности
в специальных
процедурах
чтения/записи
нет, можно вместо
имен методов
применять
имена полей.
В этом примере поле fValue модифицируется при помощи метода SetValue, а читается напрямую.
Если
свойство должно
только читаться
или только
записываться,
в его описании
может присутствовать
только соответствующий
метод: В этом примере свойство доступно только для чтения. Попытка присвоить значение свойству NotChanged вызовет ошибку компиляции.
Свойствам
можно присваивать
значения по
умолчанию.
Для этого служит
ключевое слово
default: Это означает, что при запуске программы свойство будет установлено компилятором в TRUE.
Свойство
может быть и
векторным. В
этом случае
оно выглядит
как массив:
Для
векторного
свойства
необходимо
описать не
только тип
элементов
массива, но
также и тип
индекса. После
ключевых слов
read и write должны идти
имена соответствующих
методов. Использование
здесь полей
массивов
недопустимо.
Метод, читающий
значение
векторного
свойства, должен
быть описан
как функция,
возвращающая
значение того
же типа, что
и элементы
свойства, и
имеющая единственный
параметр того
же типа и с тем
же именем, что
и индекс свойства:
Аналогично,
метод, помещающий
значения в
такое свойство,
должен первым
параметром
иметь индекс,
а вторым - переменную
нужного типа.
У векторных
свойств есть
еще одна важная
особенность:
некоторые
классы в Delphi (списки
tList, наборы строк
tStrings и т.д.) “построены”
вокруг одного
основного
векторного
свойства. Основной
метод такого
класса дает
доступ к элементам
некоторого
массива, а все
основные методы
являются как
бы вспомогательными.
Для упрощения
работы с объектами
подобного
класса можно
описать подобное
свойство с
ключевым словом
default:
Если
у объекта есть
такое свойство,
его можно не
упоминать, а
ставить индекс
в квадратных
скобках сразу
после имени
объекта: Употребляя ключевое слово default необходимо соблюдать осторожность, т.к. для обычных и векторных свойств оно употребляется в разных значениях. О роли свойств в Delphi красноречиво говорит тот факт, что у всех имеющихся в распоряжении программиста стандартных классов 100% полей недоступны и заменены базирующимися на них свойствами. Того же правила следует придерживаться и при разработке собственных классов. Наследование
Вторым
“столпом”
ООП является
наследование.
Этот простой
принцип означает,
что если необходимо
создать новый
класс, лишь
немного отличающийся
от уже имеющегося,
нет необходимости
в переписывании
заново уже
существующего
кода. Вы объявляете,
что новый класс
является потомком или дочерним классом класса tOldClass, называемого предком или родительским классом, и добавляете к нему новые поля методы и свойства.
В Delphi все
классы являются
потомками
класса tObject. Поэтому,
если вы строите
дочерний класс
прямо от tObject, то
в определении
его можно не
упоминать.
Следующие
два описания
одинаково
верны: Более подробно класс tObject будет рассмотрен ниже. Унаследованные от класса-предка поля и методы доступны в дочернем классе; если имеет место совпадение имен методов, говорят, что они перекрываются. Рассмотрим поведение методов при наследовании. По тому, какие действия происходят при вызове, методы делятся на три группы. В первую группу отнесем статические методы, во вторую - виртуальные (virtual) и динамические (dynamic) и, наконец, в третью - появившиеся только в Delphi 4 перегружаемые (overload) методы.
Статические
методы, а также
любые поля в
классах-потомках
ведут себя
одинаково:
можно без
ограничений
перекрывать
старые имена
и при этом менять
тип методов.
Код нового
статического
метода полностью
перекрывает
(заменяет собой)
код старого
метода: В этом примере разные методы с именем SetData присваивают значение разным полям с именем fData. Перекрытое (одноименное) поле предка недоступно в потомке. Поэтому два одноименных поля с именем fData приведены только для примера. В отличие от поля, внутри других методов перекрытый метод доступен при указании ключевого слова inherited. По умолчанию методы объектов классов статические - их адрес определяется еще на этапе компиляции проекта, поэтому они вызываются быстрее всего. Принципиально отличаются от статических виртуальные и динамические методы. Они должны быть объявлены путем добавления соответствующей директивы dynamic или virtual. С точки зрения наследования методы этих двух категорий одинаковы: они могут быть перекрыты в дочернем классе только одноименными методоми, имеющими тот же тип. Полиморфизм. Виртуальные и динамические методы
Рассмотрим
следующий
пример. Пусть
имеется некое
обобщенное
поле для хранения
данных - класс
tFiled и три его потомка
- для хранения
строк, целых
и вещественных
чисел: В этом примере классы содержат разнотипные поля данных fData, а также имеют унаследованный от tFiled виртуальный метод GetData, возвращающий данные в виде строки. Внешняя по отношению к ним процедура ShowData получает объект в виде параметра и показывает эту строку. Согласно правилам контроля соответствия типов (typecasting) ObjectPascal, объекту, как указателю на экземпляр класса, может быть присвоен адрес экземпляра любого из дочерних типов. Это означает, что в предыдущем примере в процедуру ShowData можно передавать объекты классов tStringFiled, tIntegerFiled, tExtendedFiled и любого другого потомка tFiled. Но какой (точнее, чей) метод GetData будет при этом вызван? Тот, который соответствует классу фактически переданного объекта. Этот принцип называется полиморфизмом. Возвращаясь к рассмотренному выше примеру, отметим, что у компилятора нет возможности определить класс объекта, фактически переданного в процедуру ShowData на этапе компиляции. Механизм, позволяющий определить этот класс прямо во время выполнения называется поздним связыванием. Естественно, такой механизм должен быть связан с передаваемым объектом. Для этого служит таблица виртуальных методов (Virtual Method Table, VMT) и таблица динамических методов (Dynamic Method Table, DMT). Различие между виртуальными и динамическими методами заключается в особенности поиска адреса. Когда компилятор встречает обращение к виртуальному методу, он подставляет вместо прямого вызова по конкретному адресу код, который обращается к VMT и извлекает оттуда нужный адрес. Такая таблица есть для каждого класса. В ней хранятся адреса всех виртуальных методов класса, независимо от того, унаследованы ли они от предка или перекрыты в данном классе. Отсюда и достоинства и недостатки виртуальных методов: они вызываются сравнительно быстро, однако для хранения указателей на них в таблице VMT требуется большое количество памяти. Динамические методы вызываются медленнее, но позволяют более экономно расходовать память. Каждому динамическому методу системой присваивается уникальный индекс. В таблице динамических методов класса хранятся индексы только тех методов только тех динамических методов, которые описаны в данном классе. При вызове динамического метода происходит поиск в этой таблице. В случае неудачи просматриваются DMT всех классов-предков в порядке их иерархии и, наконец, tObject, где имеется стандартный обработчик вызова динамических методов. Экономия памяти очевидна.
Для
перекрытия
и виртуальных
и динамических
методов служит
директива
override, с помощью
которой (и только
с ней!) можно
переопределять
оба этих типа
методов.
Первый
метод класса
tChildClass создается
заново, два
остальных
перекрываются.
Создадим объекты
этих классов:
Внутренняя структура этих объектов показана ниже. Первое поле каждого экземпляра каждого объекта содержит указатель на его класс. Класс, как структура состоит из двух частей. Начиная с адреса, на который ссылается указатель на класс, располагается таблица виртуальных методов. Она содержит адреса всех виртуальных методов класса, включая и унаследованные от предков. Перед таблицей виртуальных методов расположена специальная структура, содержащая дополнительную информацию. В ней содержатся данные, полностью характеризующие класс: имя, размер экземпляров, указатели на класс-предок и т.д. Одно из полей структуры содержит адрес таблицы динамических методов класса (DMT). Таблица имеет следующий формат: в начале - слово, содержащее количество элементов таблицы. Затем - слова, соответствующие индексам методов. Нумерация индексов начинается с –1 и идет по убывающей. После индексов идут собственно адреса динамических методов. Следует обратить внимание на то, что DMT объекта Obj1 состоит из двух элементов, Obj2 - из одного, соответствующего перекрытому методу DynamicMethod1. В случае вызова Obj2.DynamicMethod2 индекс не будет найден в DMT Obj2, и произойдет обращение к DMT Obj1. Именно так экономится память при использовании динамических методов.
Как
указывалось
выше, указатель
на класс указывает
на первый
виртуальный
метод. Служебные
данные размещаются
перед таблицей
виртуальных
методов, то
есть с отрицательным
смещением.
Эти смещения
описаны в модуле
SYSTEM.PAS:
Поля
vmtDynamicTable, vmtDispatch и vmtDefaultHandler отвечают
за вызов динамических
методов. Поля
vmtNewInstance, vmtFreeInstance и vmtDestroy содержат
адреса методов
создания и
уничтожения
экземпляров
класса. Поля
vmtIntfTable, vmtAutoTable, vmtSafeCallException введены
для обеспечения
совместимости
с моделью объекта
COM. Остальные
поля доступны
через методы
объекта tObject. В
Object Pascal эта информация
играет важную
роль и может
использоваться
программистом
неявно. В языке
определены
два оператора
- is и as, неявно
обращающиеся
к ней. Оператор
is предназначен
для проверки
совместимости
по присвоению
экземпляра
объекта с заданным
классом. Выражение
вида: Принимает значение True только если объект AnObject совместим по присвоению с классом tObjectType, то есть является объектом этого класса или его потомком.
Оператор
as введен в язык
специально
для приведения
объектных
типов. С его
помощью можно
рассматривать
экземпляр
объекта как
принадлежащий
к другому
совместимому
типу: От стандартного способа приведения типов использование оператора as отличается наличием проверки на совместимость типов во время выполнения: попытка приведения к несовместимому типу приводит к возникновению исключительной ситуации eInvalidCast. После выполнения оператора as сам объект остается неизменным, но выполняются те его методы, которые соответствуют присваиваемому классу. Вся информация, описывающая класс, создается и размещается в памяти на этапе компиляции. Доступ к информации вне методов этого класса можно получить, описав соответствующий указатель, называющийся указателем на класс или указателем на объектный тип (class reference). Он описывается при помощи зарезервированных слов class of. Например, указатель на класс tObject описан в модуле SYSTEM.PAS и называется tClass. Аналогичные указатели определены и для других важнейших классов: tComponentClass, tControlClass и т.д. С указателем на класс тесно связано понятие методов класса. Такие методы можно вызывать и без создания экземпляра объекта - с указанием имени класса в котором они описаны. Перед описанием метода класса нужно поставить ключевое слово class. Разумеется, методы класса не могут использовать значения, содержащиеся в полях класса: ведь экземпляра класса не существует!!! Методы класса служат для извлечения внутренней информации класса. Ниже перечислены методы класса tObject:
Метод
и Описание
Если Вам нужна помощь с академической работой (курсовая, контрольная, диплом, реферат и т.д.),
обратитесь к нашим специалистам. Более 90000 специалистов готовы Вам помочь.
Бесплатные корректировки и доработки. Бесплатная оценка стоимости работы.
Нужна помощь в написании работы?
Мы - биржа профессиональных авторов (преподавателей и доцентов вузов). Пишем статьи РИНЦ, ВАК, Scopus.
Помогаем в публикации. Правки вносим бесплатно.
Похожие рефераты: |