Оглавление

Часть I. Delphi и работа в Интегрированной Среде Разработки..........................................5

Глава 1. Объектно-ориентированное программирование 5

1.1. Основные понятия и определения 5

1.2. Визуальное программирование интерфейса 7

1.3. Общие вопросы построения программ 9

Глава 2. Проекты Delphi 10

2.1.Файлы проекта 10

2.2.Структура файла головной программы 11

2.3. Окно Интегрированной Среды Разработки Delphi 12

2.4. Панель главного меню и всплывающие меню 15

2.5. Форма и компоненты 16

2.5.1.Окно формы 16

2.5.2. Окно Редактора Кода 16

2.5.3. Инспектор Объектов 17

2.6. Структура модуля приложения 20

Глава 3. Элементы языка Delphi 21

3.1.Типы данных 21

3.1.1. Целый тип 21

3.1.2.Вещественный тип 22

3.1.3. Символьный тип 22

3.1.4. Строковый тип 23

3.1.5. Логический тип 23

3.2. Переменная 23

3.3. Константы 24

3.3.1.Числовые константы 24

3.3.2. Строковые и символьные константы 24

3.3.3. Логические и именованные константы 25

3.4. Инструкция присваивания 25

3.5. Стандартные функции 28

3.5.1.Математические функции 28

Глава 4. Компоненты 30

4.1. Форма и компоненты на форме 31

4.2. Событие и процедура обработки событий 35

Глава 5. Основы программирования 37

5.1. Сохранение проекта, его повторное открывание 37

5.2. Стиль программирования 38

5.3. Порядок разработки проекта 40

5.4. Управляющие структуры языка Delphi 40

5.4.1. Инструкция if 43

5.4.2. Инструкция case 49

5.5. Циклы 56

5.5.1. Инструкция for 56

5.5.2. Инструкция while 59

5.5.3. Инструкция repeat 61

5.5.4. Инструкция goto 63

5.6. Процедуры и функции 64

5.6.1. Структура функции 65

5.6.2. Структура процедуры 66

5.6.3. Ввод и вывод данных в диалоговых окнах 68

5.6.4. Запись инструкций программы 71

5.6.5. Отладка программы 73

5.7. Операции со строками 74

5.7.1. Стандартные функции и процедуры работы со строками 74

5.7.2. Использование операций со строками 75

5.8. Массивы 76

5.8.1. Объявление массива 76

5.8.2. Операции с массивами 78

5.8.3. Стандартные функции обработки массивов 84

5.8.4. Многомерные массивы 86

Часть I. Delphi и работа в Интегрированной Среде

Разработки

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

Глава 1. Объектно-ориентированное программирование

Объектно-ориентированное программирование (сокращенно ООП) – это естественный подход к построению сложных (и не очень сложных) программ и систем. Когда вы открываете любую программу Windows, вы видите окно с множеством кнопок, разделов меню, окон редакти­рования, списков и т.п. Все это объекты. Причем сами по себе они ничего не делают. Они ждут каких-то событий – нажатия пользователем клавиш или кнопок мыши, перемещения курсора и т.д. Когда происходит подобное собы­тие, объект получает сообщение об этом и как-то на него реагирует: выполняет некоторые вычисления, разворачивает список, заносит символ в окно редакти­рования. Вот такая программа Windows и есть объектно-ориентированная про­грамма (для краткости в дальнейшем на­зываем прикладные программы приложениями).

1.1. Основные понятия и определения

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

Основное понятие ООП – объект. Объект хранит в себе, как правило, какие-то данные. Данные можно рассматривать как поля записи. Это характеристики объекта. Пользователь и объекты про­граммы должны, конечно, иметь возможность читать эти данные объекта, как-то их обрабатывать и записывать в объект новые значения. Здесь важнейшее значение имеют принципы инкапсуляции и скрытия данных. Принцип скрытия данных заключается в том, что внешним объектам и пользователю прямой доступ к данным, как правило, запрещен. Делается это по двум причинам:

• для надежного функционирования объекта надо поддержи­вать целостность и непротиворечивость его данных. Если не позаботиться об этом, то внешний объект или пользователь могут занести в объект такие не­верные данные, что он начнет функционировать с ошибками;

• необходимо изолировать внешние объекты от особенностей внутренней реализации данных. Для внешних потребителей данных должен быть доступен только пользовательский интерфейс – описание того, какие имеются данные и функции и как их использовать.

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

Чтобы выдержать принцип скрытия данных, в объекте обычно определя­ются процедуры и функции, обеспечивающие все необходимые операции с данными: их чтение, преобразование, запись. Эти функции и процедуры на­зываются методами, и через них происходит общение с данными объекта. Совокупность данных и методов их чтения и записи называется свойст­вом. Свойства можно устанавливать в процессе проектирования, их можно изме­нять программно во время выполнения вашей прикладной программы. При­чем внешне это все выглядит так, как будто объект имеет какие-то данные, на­пример, целые числа, которые можно прочитать, использовать в каких-то вы­числениях, заложить в объект новые значения данных. В процессе проектиро­вания вашего приложения с помощью Delphi вы можете видеть значения неко­торых из этих данных в окне Инспектора Объектов, можете изменять эти зна­чения. В действительности все обстоит иначе. Все общение с данными проис­ходит через методы их чтения и записи. Это происходит и в процессе проекти­рования, когда среда Delphi запускает в нужный момент эти методы, и в про­цессе выполнения приложения, поскольку компилятор Delphi незримо для разработчика вставляет в нужных местах программы вызовы этих методов [1].

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

Средой взаимодействия объектов (как бы силовым полем, в котором суще­ствуют объекты) являются сообщения, генерируемые в результате различных событий. События наступают, прежде всего, вследствие действий пользовате­ля – перемещения курсора мыши, нажатия кнопок мыши или клавиш клавиатуры. Но события могут наступать и в результате работы самих объектов. В каждом объекте определено множество событий, на которые он может реаги­ровать. В конкретных экземплярах объекта могут быть определены обработ­чики каких-то из этих событий, которые и определяют реакцию данного эк­земпляра объекта. К написанию этих обработчиков, часто весьма простых, и сводится основное программирование при разработ­ке графического интерфейса пользователя с помощью Delphi.

Теперь можно окончательно определить объект как совокупность свойств и методов, а также событий, на которые он может реагировать (рис. 1.1).

Внешнее управление объектом осуществляется че­рез обработчики событий.

Эти обработчики обращаются к методам и свойствам объекта. Начальные значения данных объекта могут задаваться также в про­цессе проектирования установкой различных свойств.

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

Представление о программе как о некоторой фиксированной совокупности объектов не является полным. Чаще всего сложная программа – это не просто какая-то предопределенная совокупность объектов. В процессе работы объек­ты могут создаваться и уничтожаться. Таким образом, структура программы является динамическим образованием, меняющимся в процессе выполнения.

Основная цель создания и уничтожения объектов – экономия ресурсов компь­ютера и, прежде всего, памяти. Несмотря на бурное развитие вычислительной техники, память, наверное, всегда будет лимитировать возможности сложных приложений. Это связано с тем, что сложность программных проектов растет теми же, если не более быстрыми, темпами, что и техническое обеспечение. Поэтому от объектов, которые не нужны на данной стадии выполнения про­граммы, лучше освобождаться [1].

Рис. 1.1. Схема организации объекта

При этом освобождаются и выделенные им об­ласти памяти, которые могут использоваться вновь создаваемыми объектами. Простой пример этого – окно-заставка с логотипом, появляющееся при запус­ке многих приложений. После начала реального выполнения приложения эта заставка исчезает с экрана и никогда больше не появится в данном сеансе ра­боты. Было бы варварством не уничтожить этот объект и не освободить зани­маемую им память для более продуктивного использования. В любом сколько-нибудь сложном приложении имеется также немало диалоговых окон, ко­торые вызываются пользователем очень редко, а многими пользователями во­обще никогда не вызываются. Например, почти наверняка и вы даже не вида­ли всех диалоговых окон, предусмотренных в программе Word. А часто ли вы вызываете окно «О программе» в том же Word? Естественно, что все эти диа­логовые окна бессмысленно хранить постоянно в памяти. Они создаются в тот момент, когда пользователь их вызывает, и уничтожатся после того, как поль­зователь закончил работу с ними.

С целью организации динамического распределения памяти во все объек­ты заложены методы их создания – конструкторы и уничтожения – дест­рукторы. Конструкторы тех объектов, которые изначально должны присутст­вовать в приложении (прикладной программе), срабатывают при запуске про­граммы. Деструкторы всех объектов, имеющихся в данный момент в приложе­нии, срабатывают при нормальном (неаварийном) завершении его работы. Но нередко и в процессе выполнения различные новые объекты (например, новые окна документов) динамически создаются и уничтожаются с помощью их кон­структоров и деструкторов [1].

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