Оглавление

• Краеугольные камни ООП
  • Формула объекта
  • Природа объекта
  • Объекты и компоненты
  • Классы объектов
  • Три кита ООП
• Классы
• Объекты
• Конструкторы и деструкторы
• Методы
• Свойства
  • Понятие свойства
  • Методы получения и установки значений свойств
  • Свойства-массивы
  • Свойство-массив как основное свойство объекта
  • Методы, обслуживающие несколько свойств

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

Сейчас преимущества использования объектов очевидны для всех. Однако так было не всегда. Сначала старая гвардия не поняла и не приняла объекты, поэтому они почти 20 лет потихоньку развивались в различных языках, первым из которых была Simula 67. Постепенно объектно-ориентированный подход нашел себе место и в более мощных языках, таких как C++, Delphi и множестве других языков. Блестящим примером реализации объектов была библиотека Turbo Vision, предназначенная для построения пользовательского интерфейса программ в операционной системе MS-DOS.

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

Краеугольные камни ООП

Формула объекта

Авторы надеются, что читатель помнит кое-что из главы 2 и такие понятия как тип данных, процедура, функция, запись для него не в новинку. Это прекрасно. Так вот, в конце 60-х годов кому-то пришло в голову объединить эти понятия, и то, что получилось, назвать объектом. Рассмотрение данных в неразрывной связи с методами их обработки позволило вывести формулу объекта:

Объект = Данные + Операции

Природа объекта

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

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

Например, объект "кнопка" имеет свойство "цвет". Значение цвета кнопка запоминает в одном из своих полей. При изменении значения свойства "цвет" вызывается метод, который перерисовывает кнопку.

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

Объекты и компоненты

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

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

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

Классы объектов

Каждый объект всегда принадлежит некоторому классу объектов. Класс объектов - это обобщенное (абстрактное) описание множества однотипных объектов. Объекты являются конкретными представителями своего класса, их принято называть экземплярами класса. Например, класс СОБАКИ - понятие абстрактное, а экземпляр этого класса МОЙ ПЕС БОБИК - понятие конкретное.

Три кита ООП

Весь мир ООП держится на трех китах: инкапсуляции, наследовании и полиморфизме. Для начала о них надо иметь только самое общее представление.

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

Второй кит ООП - наследование. Этот простой принцип означает, что если вы хотите создать новый класс объектов, который расширяет возможности уже существующего класса, то нет необходимости в переписывании заново всех полей, методов и свойств. Вы объявляете, что новый класс является потомком (или дочерним классом) имеющегося класса объектов, называемого предком (или родительским классом), и добавляете к нему новые поля, методы и свойства. Процесс порождения новых классов на основе других классов называется наследованием. Новые классы объектов имеют как унаследованные признаки, так и, возможно, новые. Например, класс СОБАКИ унаследовал многие свойства своих предков - ВОЛКОВ.

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

Классы

Для поддержки ООП в язык Delphi введены объектные типы данных, с помощью которых одновременно описываются данные и операции над ними. Объектные типы данных называют классами, а их экземпляры - объектами.

Классы объектов определяются в секции type глобального блока. Описание класса начинается с ключевого слова class и заканчивается ключевым словом end. По форме объявления классы похожи на обычные записи, но помимо полей данных могут содержать объявления пользовательских процедур и функций. Такие процедуры и функции обобщенно называют методами, они предназначены для выполнения над объектами различных операций. Приведем пример объявления класса, который предназначен для чтения текстового файла в формате "delimited text" (файл в таком формате представляет собой последовательность строк; каждая строка состоит из значений, которые отделены друг от друга символом-разделителем):

type
 TDelimitedReader = class
 // Поля
 FileVar: TextFile;
 Items: array of string;
 Delimiter: Char;
 // Методы
 procedure PutItem(Index: Integer; const Item: string);
 procedure SetActive(const AActive: Boolean);
 function ParseLine(const Line: string): Integer;
 function NextLine: Boolean;
 function GetEndOfFile: Boolean;
 end;

Класс содержит поля (FileVar, Items, Delimiter) и методы (PutItem, SetActive, ParseLine, NextLine, GetEndOfFile). Заголовки методов, (всегда) следующие за списком полей, играют роль упреждающих (forward) описаний. Программный код методов пишется отдельно от определения класса и будет приведен позже.

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

Класс содержит несколько полей:

• FileVar - файловая переменная, необходимая для доступа к файлу;
• Delimiter - символ, который служит разделителем элементов;
• Items - массив элементов, полученных разбором последней считанной строки;

Класс также содержит ряд методов (процедур и функций):

• PutItem - помещает элемент в массив Items по индексу Index; если индекс превышает верхнюю границу массива, то размер массива автоматически увеличивается;
• SetActive - открывает или закрывает файл, из которого производится чтение строк;
• ParseLine - осуществляет разбор строки: выделяет элементы из строки и помещает их в массив Items; возвращает количество выделенных элементов;
• NextLine - считывает очередную строку из файла и с помощью метода ParseLine осуществляет ее разбор; в случае успешного чтения очередной строки функция возвращает значение True, а иначе - значение False (достигнут конец файла);
• GetEndOfFile - возвращает булевское значение, показывающее, достигнут ли конец файла.

Обратите внимание, что приведенное выше описание является ничем иным, как декларацией интерфейса для работы с объектами класса TDelimitedReader. Реализация методов PutItem, SetActive, ParseLine, NextLine и GetEndOfFile на данный момент отсутствует, однако для создания и использования экземпляров класса она пока и не нужна.

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

Объекты

Чтобы от описания класса перейти к объекту, следует выполнить соответствующее объявление в секции var:

var
 Reader: TDelimitedReader;

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

Reader := TDelimitedReader.Create;

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

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

Reader.NextLine;

Кроме того, как и при работе с записями, допустимо использование оператора with, например:

with Reader do
 NextLine;

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

Reader.Destroy; // Освобождение памяти, занимаемой объектом

Destroy - это так называемый деструктор объекта; он присутствует в классе наряду с конструктором и служит для удаления объекта из динамической памяти. После вызова деструктора переменная Reader становится несвязанной и не должна использоваться для доступа к полям и методам уже несуществующего объекта. Чтобы отличать в программе связанные объектные переменные от несвязанных, последние следует инициализировать значением nil. Например, в следующем фрагменте обращение к деструктору Destroy выполняется только в том случае, если объект реально существует:

Reader := nil;
...
if Reader <> nil then Reader.Destroy;

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

Reader.Free;

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

Reader.Free;
Reader := nil;

С помощью стандартной процедуры FreeAndNil это можно сделать проще и элегантнее:

FreeAndNil(Reader); // Эквивалентно: Reader.Free; Reader := nil;

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

var
 R1, R2: TDelimitedReader; // Переменные R1 и R2 не связаны с объектом
begin
 R1 := TDelimitedReader.Create; // Связывание переменной R1 с новым объектом
 // Переменная R2 пока еще не связана ни с каким объектом
 R2 := R1; // Связывание переменной R2 с тем же объектом, что и R1 
 // Теперь обе переменные связаны с одним объектом
 R2.Free; // Уничтожение объекта
 // Теперь R1 и R2 не связаны ни с каким объектом 
end;

Объекты могут выступать в программе не только в качестве переменных, но также элементов массивов, полей записей, параметров процедур и функций. Кроме того, они могут служить полями других объектов. Во всех этих случаях программист фактически оперирует указателями на экземпляры объектов в динамической памяти. Следовательно, объекты изначально приспособлены для создания сложных динамических структур данных, таких как списки и деревья. Указатели на объекты для этого не нужны.

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

type
 TReadersList = class; // упреждающее объявление класса TReadersList
 
 TDelimitedReader = class
 Owner: TReadersList;
 ...
 end;
 
 TReadersList = class
 Readers: array of TDelimitedReader;
 ...
 end;

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

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

Конструкторы и деструкторы

Особой разновидностью методов являются конструкторы и деструкторы. Напомним, что конструкторы создают, а деструкторы разрушают объекты. Создание объекта включает выделение памяти под экземпляр и инициализацию его полей, а разрушение - очистку полей и освобождение памяти. Действия по инициализации и очистке полей специфичны для каждого конкретного класса объектов. По этой причине язык Delphi позволяет переопределить стандартный конструктор Create и стандартный деструктор Destroy для выполнения любых полезных действий. Можно даже определить несколько конструкторов и деструкторов (имена им назначает сам программист), чтобы обеспечить различные процедуры создания и разрушения объектов.

Объявление конструкторов и деструкторов похоже на объявление обычных методов с той лишь разницей, что вместо зарезервированных слов function и procedure используются слова constructor и destructor. Для нашего класса TDelimitedReader потребуется конструктор, которому в качестве параметра будет передаваться имя обрабатываемого файла и разделитель элементов:

type
 TDelimitedReader = class
 ...
 // Конструкторы и деструкторы
 constructor Create(const FileName: string; const ADelimiter: Char = ';');
 destructor Destroy; override;
 ...
 end;

Приведем их возможную реализацию:

constructor TDelimitedReader.Create(const FileName: string;
 const ADelimiter: Char = ';');
begin
 AssignFile(FileVar, FileName);
 Delimiter := ADelimiter;
end;
 
destructor TDelimitedReader.Destroy;
begin
 // Пока ничего не делаем
end;

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

Конструктор применяется к классу или к объекту. Если он применяется к классу,

Reader := TDelimitedReader.Create('MyData.del', ';');

то выполняется следующая последовательность действий:

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

Если конструктор применяется к объекту,

Reader.Create('MyData.del', ';');

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

Деструктор уничтожает объект, к которому применяется:

Reader.Destroy;

В результате:

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

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

Методы

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

procedure TDelimitedReader.SetActive(const AActive: Boolean);
begin
 if AActive then
 Reset(FileVar) // Открытие файла
 else
 CloseFile(FileVar); // Закрытие файла
end;

Обратите внимание, что внутри методов обращения к полям и другим методам выполняются как к обычным переменным и подпрограммам без уточнения экземпляра объекта. Такое упрощение достигается путем использования в пределах метода псевдопеременной Self (стандартный идентификатор). Физически Self представляет собой дополнительный неявный параметр, передаваемый в метод при вызове. Этот параметр и указывает экземпляр объекта, к которому данный метод применяется. Чтобы пояснить сказанное, перепишем метод SetActive, представив его в виде обычной процедуры:

procedure TDelimitedReader_SetActive(Self: TDelimitedReader;
 const AActive: Boolean);
begin
 if AActive then
 Reset(Self.FileVar) // Открытие файла
 else
 CloseFile(Self.FileVar); // Закрытие файла
end;

Согласитесь, что метод SetActive выглядит лаконичнее процедуры TDelimitedReader_SetActive.

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

Если выполнить метод SetActive,

Reader.SetActive(True);

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

TDelimitedReader_SetActive(Reader, True);

Свойства

Понятие свойства

Помимо полей и методов в объектах существуют свойства. При работе с объектом свойства выглядят как поля: они принимают значения и участвуют в выражениях. Но в отличие от полей свойства не занимают места в памяти, а операции их чтения и записи ассоциируются с обычными полями или методами. Это позволяет создавать необходимые сопутствующие эффекты при обращении к свойствам. Например, в объекте Reader присваивание свойству Active значения True вызовет открытие файла, а присваивание значения False - закрытие файла. Создание сопутствующего эффекта (открытие или закрытие файла) достигается тем, что за присваиванием свойству значения стоит вызов метода.

Объявление свойства выполняется с помощью зарезервированного слова property, например:

type
 TDelimitedReader = class
 ...
 FActive: Boolean;
 ...
 // Метод записи (установки значения) свойства
 procedure SetActive(const AActive: Boolean);
 property Active: Boolean read FActive write SetActive; // Свойство
 end;

Ключевые слова read и write называются спецификаторами доступа. После слова read указывается поле или метод, к которому происходит обращение при чтении (получении) значения свойства, а после слова write - поле или метод, к которому происходит обращение при записи (установке) значения свойства. Например, чтение свойства Active означает чтение поля FActive, а установка свойства - вызов метода SetActive. Чтобы имена свойств не совпадали с именами полей, последние принято писать с буквы F (от англ. field). Мы в дальнейшем также будем пользоваться этим соглашением. Начнем с того, что переименуем поля класса TDelimitedReader: поле FileVar переименуем в FFile, Items - в FItems, а поле Delimiter - в FDelimiter.

type
 TDelimitedReader = class
 // Поля
 FFile: TextFile; // FileVar -> FFile
 FItems: array of string; // Items -> FItems
 FActive: Boolean;
 FDelimiter: Char; // Delimiter -> FDelimiter
 ...
 end;

Обращение к свойствам выглядит в программе как обращение к полям:

var
 Reader: TDelimitedReader;
 IsOpen: Boolean;
...
 Reader.Active := True; // Эквивалентно Reader.SetActive(True);
 IsOpen := Reader.Active; // Эквивалентно IsOpen := Reader.FActive

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

type
 TDelimitedReader = class
 ...
 FItems: array of string;
 ...
 function GetItemCount: Integer;
 ...
 property ItemCount: Integer read GetItemCount; // Только для чтения!
 end;
 
function TDelimitedReader.GetItemCount: Integer;
begin
 Result := Length(FItems);
end;

Здесь свойство ItemCount показывает количество элементов в массиве FItems. Поскольку оно определяется в результате чтения и разбора очередной строки файла, пользователю объекта разрешено лишь узнавать количество элементов.

В отличие от полей свойства не имеют адреса в памяти, поэтому к ним запрещено применять операцию @. Как следствие, их нельзя передавать в var- и out-параметрах процедур и функций.

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

Методы получения и установки значений свойств

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

type
 TDelimitedReader = class
 FActive: Boolean;
 ...
 procedure SetActive(const AActive: Boolean);
 function GetItemCount: Integer;
 ...
 property Active: Boolean read FActive write SetActive;
 property ItemCount: Integer read GetItemCount;
 end;

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

procedure TDelimitedReader.SetActive(const AActive: Boolean);
begin
 if Active <> AActive then // Если состояние изменяется
 begin
 if AActive then
 Reset(FFile) // Открытие файла
 else
 CloseFile(FFile); // Закрытие файла
 FActive := AActive; // Сохранение состояния в поле
 end;
end;

Наличие свойства Active позволяет нам отказаться от использования методов Open и Close, традиционных при работе с файлами. Согласитесь, что открывать и закрывать файл с помощью свойства Active гораздо удобнее и естественнее. Одновременно с этим свойство Active можно использовать и для проверки состояния файла (открыт или нет). Таким образом, для осуществления трех действий требуется всего лишь одно свойство! Это делает использование Ваших классов другими программистами более простым, поскольку им легче запомнить одно понятие Active, чем, например, три метода: Open, Close и IsOpen.

Значение свойства может не храниться, а вычисляться при каждом обращении к свойству. Примером является свойство ItemCount, значение которого вычисляется как Length(FItems).

Свойства-массивы

Кроме обычных свойств в объектах существуют свойства-массивы (array properties). Свойство-массив - это индексированное множество значений. Например, в классе TDelimitedReader множество элементов, выделенных из считанной строки, удобно представить в виде свойства-массива:

type
 TDelimitedReader = class
 ...
 FItems: array of string;
 ...
 function GetItem(Index: Integer): string;
 ...
 property Items[Index: Integer]: string read GetItem; 
 end;
 
function TDelimitedReader.GetItem(Index: Integer): string;
begin
 Result := FItems[Index];
end;

Элементы массива Items можно только читать, поскольку класс TDelimitedReader предназначен только для чтения данных из файла.

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

Основная выгода от применения свойства-массива - возможность выполнения итераций с помощью цикла for, например:

var
 Reader: TDelimitedReader;
 I: Integer;
...
 for I := 0 to Reader.ItemCount - 1 do
 Writeln(Reader.Items[I]);
...

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

Свойства-массивы имеют два важных отличия от обычных массивов:

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

Reader.Items['FirstName'] := 'Alexander';

операции над свойством-массивом в целом запрещены; разрешены операции только с его элементами.

Свойство-массив как основное свойство объекта

Свойство-массив можно сделать основным свойством объектов данного класса. Для этого в описание свойства добавляется слово default:

type
 TDelimitedReader = class
 ...
 property Items[Index: Integer]: string read GetItem; default;
 ...
 end;

Такое объявление свойства Items позволяет рассматривать сам объект класса TDelimitedReader как массив и опускать имя свойства-массива при обращении к нему из программы, например:

var
 R: TDelimitedReader;
 I: Integer;
...
 for I := 0 to R.ItemCount - 1 do
 Writeln(R[I]);
...

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

Методы, обслуживающие несколько свойств

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

В следующем примере уже известный Вам метод GetItem обслуживает три свойства: FirstName, LastName и Phone:

type
 TDelimitedReader = class
 ...
 property FirstName: string index 0 read GetItem;
 property LastName: string index 1 read GetItem;
 property Phone: string index 2 read GetItem;
 end;

Обращения к свойствам FirstName, LastName и Phone заменяются компилятором на вызовы одного и того же метода GetItem, но с разными значениями параметра Index:

var
 Reader: TDelimitedReader;
...
 Writeln(Reader.FirstName); // Эквивалентно: Writeln(Reader.GetItem(0));
 Writeln(Reader.LastName); // Эквивалентно: Writeln(Reader.GetItem(1));
 Writeln(Reader.Phone); // Эквивалентно: Writeln(Reader.GetItem(2));
...

Обратите внимание, что метод GetItem обслуживает как свойство-массив Items, так и свойства FirstName, LastName и Phone. Удобно, не правда ли!

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

type
 TDelimitedReader = class
 // Поля
 FFile: TextFile;
 FItems: array of string;
 FActive: Boolean;
 FDelimiter: Char;
 // Методы чтения и записи свойств
 procedure SetActive(const AActive: Boolean);
 function GetItemCount: Integer;
 function GetEndOfFile: Boolean;
 function GetItem(Index: Integer): string;
 // Методы
 procedure PutItem(Index: Integer; const Item: string);
 function ParseLine(const Line: string): Integer;
 function NextLine: Boolean;
 // Конструкторы и деструкторы
 constructor Create(const FileName: string; const ADelimiter: Char = ';');
 destructor Destroy; override;
 // Свойства
 property Active: Boolean read FActive write SetActive;
 property Items[Index: Integer]: string read GetItem; default;
 property ItemCount: Integer read GetItemCount;
 property EndOfFile: Boolean read GetEndOfFile;
 property Delimiter: Char read FDelimiter;
 end;
 
{ TDelimitedReader }
 
constructor TDelimitedReader.Create(const FileName: string;
 const ADelimiter: Char = ';');
begin
 AssignFile(FFile, FileName);
 FActive := False;
 FDelimiter := ADelimiter;
end;
 
destructor TDelimitedReader.Destroy;
begin
 Active := False;
end;
 
function TDelimitedReader.GetEndOfFile: Boolean;
begin
 Result := Eof(FFile);
end;
 
function TDelimitedReader.GetItem(Index: Integer): string;
begin
 Result := FItems[Index];
end;
 
function TDelimitedReader.GetItemCount: Integer;
begin
 Result := Length(FItems);
end;
 
function TDelimitedReader.NextLine: Boolean;
var
 S: string;
 N: Integer;
begin
 Result := not EndOfFile;
 if Result then // Если не достигнут конец файла
 begin
 Readln(FFile, S); // Чтение очередной строки из файла
 N := ParseLine(S); // Разбор считанной строки
 if N <> ItemCount then
 SetLength(FItems, N); // Отсечение массива (если необходимо)
 end;
end;
 
function TDelimitedReader.ParseLine(const Line: string): Integer;
var
 S: string;
 P: Integer;
begin
 S := Line;
 Result := 0;
 repeat
 P := Pos(Delimiter, S); // Поиск разделителя
 if P = 0 then // Если разделитель не найден, то считается, что
 P := Length(S) + 1; // разделитель находится за последним символом
 PutItem(Result, Copy(S, 1, P - 1)); // Установка элемента
 Delete(S, 1, P); // Удаление элемента из строки
 Result := Result + 1; // Переход к следующему элементу
 until S = ''; // Пока в строке есть символы
end;
 
procedure TDelimitedReader.PutItem(Index: Integer; const Item: string);
begin
 if Index > High(FItems) then // Если индекс выходит за границы массива,
 SetLength(FItems, Index + 1); // то увеличение размера массива
 FItems[Index] := Item; // Установка соответствующего элемента
end;
 
procedure TDelimitedReader.SetActive(const AActive: Boolean);
begin
 if Active <> AActive then // Если состояние изменяется
 begin
 if AActive then
 Reset(FFile) // Открытие файла
 else
 CloseFile(FFile); // Закрытие файла
 FActive := AActive; // Сохранение состояния в поле
 end;
end;