Объектно-ориентированный
подход к программированию
Объект можно
сравнивать с черным ящиком. Фокусник кладет в него платочек, говорит заветное
заклинание, и вытаскивает кролика. Так же и мы. Мы можем инициализировать
объект, или он сам инициализируется значениями по умолчанию, вызвать нужный
метод объекта, и получить результат. Нас мало интересует то, что в нем
конкретно происходит, если объект уже достаточно хорошо отлажен. Основная идея
объектно-ориентированного подхода заключается в наличие интерфейса, который
служит для полиморфного обращения с объектом и его потомками. За счет наличия
интерфейса легко достигается повторное использование кода. Многие программисты,
переходящие от процедурного программирования к объектно-ориентированному
программированию справедливо замечают, что они могут сделать все то же самое и
без использования объектов. Объектно-ориентированное программирование - это
всего лишь соглашение о правилах построения программ. Вся мощь объектной
ориентации раскрывается в крупных проектах, или при написании большого
количества однотипных программ, например программ, работающих с базами данных.
За счет повторного использования кода достигается простота в работе
программиста (накопление опыта), сокращается размер программы (методы объектов
одного типа или методы, наследуемые от предков потомками существуют в
единственном экземпляре), самодокументируемость, а значит и больше простоты при
отладке (объекты описываются в определенном месте программы отдельно от
реализации), простота сопровождения программы (не меняя интерфейс объекта, Вы
можете изменить реализацию методов) и т.д. Но, это только в идеале. На самом
деле достаточно просто извратить постулаты объектной ориентированности. Все
зависит от правильности и лаконичности дерева наследования Вашей библиотеки
объектов. Нам повезло, Мы можем использовать в своей работе последнее
достижение в области объектно-ориентированного программирования - продукт
компании Borland-Inprise Delphi.При дальнейшем чтении текста, если Вам будет
сразу что-то непонятно, то продолжайте читать дальше. В такой сложной теме
трудно последовательно изложить все по порядку, т.к. многие вопросы
переплетаются с более сложными и наоборот. По ходу чтения текста, Вы составите
полное представление о теме.
Объектно-ориентированное
программирование.
Объект в Delphi
представляет из себя специальную структуру, которая описывает поля, свойства и
методы объекта - class. Предком для всех объектов служит class Tobject. Давайте
рассмотрим простой объект.
Type
TmyObject = class(TObject)
Private // закрытая часть
AmyField: Integer; // Свойство
Protected // Защищенная часть
Procedure SetMyField(Val: Integer); // Процедура записи свойства класса
Public // Открытая часть
Constructor Create; // Конструктор
Destructor Destroy; override; // Деструктор
Property MyField: Integer read AmyField write
SetMyField; // Свойство класса
End;
Имена классов
принято начинать с буквы T, но это просто соглашение, а не правило. Вы можете
назвать Ваш объект как хотите. Однако, буква Т в начале имени класса - это
правило хорошего тона. Далее, указывается, что этот класс является потомком от
Tobject. Если Вы запишите TmyClass = class, то все равно ваш класс будет
потомком от Tobject. Далее, идет закрытая часть интерфейса класса. Здесь
объявляются свойства и методы класса, которые будут доступными только из
методов этого же класса, и будут недоступными для других классовых методов и из
других модулей программы. При наследовании класса, потомок тоже не будет иметь
доступа к закрытой части интерфейса. Иногда, такое поведение класса неудобно.
Например, при большом количестве обращений к списку данных одного класса из
другого через открытую часть интерфейса, при каждом обращении, возможно, будут
проверяться допустимые границы индекса списка. Это правильно, но может
значительно замедлить работу программы, поэтому было бы неплохо иметь
возможность для ограниченного числа классов или функций разрешить доступ к
закрытой части, чтобы они могли обращаться к свойствам класса, объявленным в
закрытой части. Возможно, Вы писали на С++ и знаете, что там такие классы и
функции называются друзьями. В Delphi эта возможность реализуется через
объявление дружественных классов и функций в одном модуле программы, т.е. все
друзья должны быть объявлены в одном модуле. Далее, идет защищенная часть. Она
отличается от закрытой тем, что из потомка класса, Вы можете иметь доступ к
этой части. Далее, идет открытая часть интерфейса. Здесь Вы можете объявить
свойства и методы класса, которые будут доступны для других классов, процедур и
функций. Есть еще одна часть интерфейса - published (опубликованная). Эта часть
имеет место у потомков от Tcomponent. Delphi использует эту часть интерфейса в
инспекторе объектов. При доступе к классу во время выполнения программы, эта
часть ничем не отличается от public. Здесь имеет смысл объявлять свойства и
события класса. Все свойства и события будут доступны из инспектора объектов, и
Вы сможете редактировать их во время разработки. Чтобы работать с классом, Вы
должны объявить переменную объектного типа этого класса, затем инициализировать
ее вызовом конструктора.
Type
TmyClass = class(TObject) // Объявление класса
…
end;
…
Var
AmyClass:
TmyClass; // Объявление переменной класса
begin
AmyClass:=TmyClass.Create;
// Вызов конструктора, обратите внимание на то, что вызывается конструктор// TmyClass.Create, а не AmyClass.Create
Try
…
finally
AmyClass.Free; // Уничтожение класса
End;
end;
Классы в Delphi
могут создаваться только в динамической памяти, поэтому все переменные
объектного типа - это указатели на экземпляр класса в динамической памяти.
Типичное имя конструктора - Create, типичное имя деструктора - Destroy.
Придерживайтесь этого правила, если нет особой необходимости в обратном.
Инициализация
и разрушение объектов
Для объявления
конструктора используется зарезервированное слово constructor, после которого
идет имя конструктора и параметры, если необходимо. Конструктор возвращает
указатель на экземпляр класса. У конструктора Tobject имя Create, поэтому у
всех потомков этого класса есть конструктор Create, хотя, у некоторых классов
есть и другие конструкторы с другими именами, например у обработчиков
исключений. В теле конструктора Вы можете вызвать конструктор предка для
инициализации закрытой части предка значениями по умолчанию, например:
unit MyUnit;
interface
Type
TmyClass = class(TComponent)
…
public
constructor Create(AOwner: TComponent); override; // перегружаем конструктор предка
…
end;
implementation
Constructor TmyClass.Create(AOwner: TComponent);
Begin
Inherited
Create(Aowner); // Вызов конструктора предка
… //
Дальнейшая инициализация объекта
End;
Если имя
конструктора предка совпадает с именем потомка, то можно сократить запись при
вызове конструктора предка в конструкторе потомка:
Constructor TmyClass.Create(AOwner: TComponent);
Begin
Inherited
(Aowner); // Вызов конструктора предка
… //
Дальнейшая инициализация объекта
End;
Для уничтожение
объекта служит деструктор. Деструктор объявляется с помощью зарезервированного
слова destructor, после которого идет имя деструктора. Деструктор ничего не
возвращает и не имеет параметров. Я советую Вам вместо прямого вызова
деструктора использовать метод Free. Этот метод есть у всех классов в Delphi,
т.к. наследуется от Tobject. Этот метод сначала проверяет неравенство указателя
на класс nil, а затем только вызывает Destroy. Это более безопасный способ
уничтожить объект.unit
MyUnit;
interface
Type
TmyClass = class(TComponent)
…
public
constructor Create(AOwner: TComponent); override; // перегружаем конструктор предка
destructor Destroy; override // Перегружаем деструктор предка
…
end;
implementation
…
destructor TmyClass.Destroy;
Begin
… //
Уничтожение объекта
Inherited
Destroy; // Вызов деструктора предка, для уничтожение закрытых полей предка
End;
Инкапсуляция
Суть
объектно-ориентированного подхода к программированию заключается в трех
принципах: инкапсуляции, наследовании и полиморфизме. Для более надежной работы
программы, Вы не должны напрямую обращаться к полям объекта. Вместо этого, Вы
должны обращаться через специальные методы, которые могут проверить, например,
на допустимость значения в заданном интервале или одновременно выполнить
дополнительную работу по изменению состояния объекта, в зависимости от
изменения значения поля - это и есть инкапсуляция. Такая возможность
реализуется в классах через объявление свойств объекта. Свойство позволяет
ограничить права на изменение значения поля и организует доступ к полю через
методы. Вот пример описания класса со свойством:
Type
TmyClass = class(TObject)
Private
AmyField:
Integer; // Объявление поля целого типа
Protected
Procedure
SetMyField(Val: Integer); virtual; // Объявление процедуры для записи значения
свойства
Public
Property MyField: Integer read AmyField write
SetMyField; // объявление свойства
End;
Здесь мы видим,
что свойство MyField является целым типом. Оно доступно для чтения и записи,
т.к. объявлены методы read и write. Процедура, организующая запись значения
объявлена в секции protected для того, чтобы в случае необходимости, Вы могли
перегрузить ее в потомке. На самом деле значение свойства хранится в поле
AmyField класса. Если Вы не объявите метода write, то свойство станет доступным
только по чтению, аналогично и с методом read. К слову говоря, поля для
хранения значения свойства может и не быть, главное, чтобы были объявлены
методы доступа к нему. Для примера, класс, реализующий интерфейс доступа к
свойствам дисплея, мог бы иметь свойства ширина и высота в пикселях. Вам не
обязательно хранить эти значения, т.к. можно вызвать стандартную функцию
Windows и узнать ширину и высоту экрана, тем более, что в процессе работы эти
значения могут меняться при переключении в другой режим. Методы записи и чтения
свойства подчиняются жестким правилам. Так для чтения свойства, Вам необходимо
объявить функцию без формальных параметров, возвращающую значение того же типа,
что и свойство. Для записи значения, Вам необходимо объявить процедуру с одним
параметром того же типа, что и свойство. Если в качестве метода для записи или
чтения свойства Вы указываете имя поля для хранения значения свойства, то это
аналогично прямому доступу к этому полю. При компиляции такого способа
обращения к свойству, код будет оптимизирован, поэтому это не повлечет никаких
дополнительных расходов ресурсов компьютера. Обычно, такой метод обращения к
полю применяют для чтения. Методы доступа к полям класса могут выполнять
дополнительную работу при переустановке значения поля класса. Так, при
установке свойства Ttable.Active в true производится чтение данных из таблицы
базы данных на жестком диске, несколько раз меняется состояние объекта,
посылаются события связанным объектам, вызываются обработчики делегированных
событий, которые пишет программист, и только потом переустанавливается значение
свойства в true. Для присвоения свойству значения по умолчанию, используется
ключевое слово default, например:
property
Visible: boolean read Avisible write SetVisible default true;Это значит, что при запуске программы,
компилятор установить это свойство в true. Однако я настоятельно рекомендую Вам
устанавливать значение свойств по умолчанию в конструкторе класса.Вы можете
иметь индексированные свойства. Вот пример реализации такого класса.
Type
TmyClass = class(TObject);
private
AmyList: Tlist; // Контейнер указателей
Protected
Function GetMyList(Index: Integer): Pointer; // Функция доступа по чтению
Procedure SetMyList(Index: Integer; Val: Pointer); // Процедура доступа по записи
Public
…
Property MyList[Index: Integer]: Pointer read
GetMyList write SetMyList; // Объявление индексированного свойства
End;
Здесь мы видим,
что свойство MyList
индексированно - это элемент списка указателей. В квадратных скобках Вам нужно
указать список индексов и их типов. В общем случае, индексом может быть даже
строка символов. Далее идет тип свойства и методы записи и чтения. Функция
чтения должна иметь список формальных параметров со всеми индексами свойства и
возвращать значение того же типа, что и свойство. Процедура записи должна иметь
список формальных параметров со всеми индексами свойства и параметр для
передачи устанавливаемого значения того же типа что и свойство. Большое
значение имеет последовательность указания индексов и обязательность передачи
значения свойства в процедуре записи последним в списке формальных параметров.
Если индексированное свойство является основным и обращение именно к нему
производится чаще остальных, то можно объявить его как default, тогда не нужно
указывать имя свойство для доступа к нему, например:
Type
TmyClass = class(TObject);
private
AmyList: Tlist; // Контейнер указателей
Protected
Function GetMyList(Index: Integer): Pointer; // Функция доступа по чтению
Procedure SetMyList(Index: Integer; Val: Pointer); // Процедура доступа по записи
Public
…
Property MyList[Index: Integer]: Pointer read
GetMyList write SetMyList; default; // Объявление индексированного свойства по умолчанию
End;
…
Var
MyClass: TmyClass;
Begin
MyClass:= TmyClass.Create;
…
MyClass [3]:=AnyObject; // Аналогично MyClass.MyList[3] ]:=AnyObject;
…
End;
Значение
инкапсуляции в объектно-ориентированном программировании трудно переоценить.
Чего стоит хотя бы то, что в Delphi к 100% полей классов доступ организован
через свойства.
Наследование
Если Вы хотите
изменить или дополнить поведение уже существующего класса, то нет никакой
необходимости переписывать класс заново. Вам стоит воспользоваться
наследованием. Вы должны объявить, что новый класс является потомком уже
существующего и добавить в новый класс свойства и методы, которые Вам необходимы
или перекрыть существующие методы и свойства:
Type
TmyFirstClass = class(TObject)
Private
Protected
Public
Constructor Create(Val: Integer); virtual;
end;
TmySecondClass = class(TMyFirstClass)
Private
AmyField: string; // Добавили новое поле
Protected
Procedure SetMyField(Val: string); // Добавили процедуру
Public
Constructor Create(Val: Integer); override; // Перегрузили конструктор
Property MyField: string read AmyField write
SetMyField; // Добавили свойство
End;
Есть несколько
правил области видимости объекта, которые помогут Вам разобраться со способами
доступа к объектам и наследования объектов:
Поля, свойства
и методы секции public не имеют ограничений на видимость.
Поля, свойства
и методы секции private, доступны только в методах класса и в функциях,
объявленных в том же модуле, где и класс.
Поля, свойства
и методы секции protected тоже доступны только из методов класса и функций,
объявленных в модуле, но они доступны в классах, являющихся потомками, в том
числе и объявленных в других модулях.
При описании
потомков, Вы можете изменять область видимости методов и свойств. Можно
расширять область видимости, но не сужать. Т.е. если есть свойство в секции
private, вы можете сделать его public, но не наоборот. Вот пример расширения
области видимости:
Type
TmyClass=class(TObject)
Private
AmyField: Integer;
protected
property MyField: Integer read AmyField;
…
End;
TmySunClass = class(TMyClass)
…
Public
Property
MyField; // Только упомянули его в другой секции и он поменял область
видимости.
End;
Унаследованные
поля и методы потомка имеются и в предке. При совпадении имен предка и потомка
говорят о перекрытии потомком полей или методов предка. По способу вызова
методы класса можно разделить на статические, виртуальные, динамические,
перегружаемые и абстрактные. Абстрактные методы не имеют реализации и должны
быть обязательно перекрыты в потомках. Абстрактными могут быть только
виртуальные и динамические методы, например :
Type
TmyClass=class(TObject)
…
protected
procedure MyMethod(Val: Integer); virtual; abstract;
…
End;
Статические
методы и поля в объектах-потомках перекрываются одинаково: Вы можете без
ограничений перекрывать старые имена и при этом изменять тип методов, т.к. при
перекрытии будет создано новое поле или метод с тем же именем. Перекрытый метод
предка доступен в потомке через зарезервированное слово inherited.Type
TmyClass=class(TObject)
…
protected
procedure MyMethod;
…
End;
TmySunClass=class(TmyClass)
…
protected
procedure MyMethod(Val: Integer);
…
End;
…procedure TmySunClass.MyMethod(Val: Integer);begin
inherited
MyMethod; // Метод предка без параметров, а метод потомка уже с параметром,
т.е. мы поменяли тип процедуры.
…
end;
По умолчанию
все методы - статические, поэтому их адреса известны уже на стадии компиляции,
они будут вызываться при выполнении программы самым быстрым способом.
Виртуальные и динамические методы описываются с помощью специальных директив
virtual или dynamic. Эти методы могут быть перекрыты в потомке одноименными
методами, имеющими тот же тип.
И наконец, хочу
сказать, что Delphi не поддерживает множественного наследования. Для достижения
того же самого, Вам придется использовать простое наследование от одного из
нужных классов, а второй класс добавить как поле, и организовать доступ к свойствам
второго класса через свойства наследника. Так можно соединить несколько
классов. Другой способ - это создать класс-контейнер, в котором в качестве
полей будут нужные включенные классы, а интерфейс доступа к ним организовать
через свойства контейнера.
Полиморфизм
Указателю на
экземпляр объектного типа может быть присвоен адрес любого экземпляра любого из
дочерних типов. При обращении к свойствам и методам через этот указатель будет
доступен именно экземпляр, адрес которого был присвоен, а не предок. Это и есть
полиморфизм. Т.е. Вы можете иметь доступ к потомку через указатель объектного
типа предка. Рассмотрим пример:
Type
TMyClass = class(TObject)
…
public
procedure GetData: string; virtual; abstract;
…
end;
TmySun1Class = class(TMyClass)
Protected
AmyField: string;
…
public
procedure GetData: string; override;
…
end;
TmySun2Class = class(TMyClass)
Protected
AmyField: Integer;
…
public
procedure GetData: string; override;
…
end;
…
implementation
procedure TmySun1Class.GetData: string;
begin
Result:= AmyField;
end;
procedure TmySun2Class.GetData: string;
begin
Result:=IntToStr(AmyField);
end;
…
Var
MyClass: TmyClass;
Class1: TmySun1Class;
Class2: TmySun2Class;
Begin
Class1:=TmySun1Class.Create;
Class2:=TmySun2Class.Create;
…
MyClass:= Class1;
Label1.Caption:= MyClass.GetData;
MyClass:= Class2;
Label2.Caption:= MyClass.GetData;
end;
Если посмотреть
на этот код внимательно, то можно понять, что у компилятора нет возможности
определить метод какого именно класса нужно вызывать. Поэтому, для определения
адреса метода используются специальные таблицы, где хранятся адреса на
виртуальные и динамические методы: VMT - таблица виртуальных методов и DMT -
таблица динамических методов. Когда компилятор встречает указатель на
виртуальный метод, то он ищет его адрес в VMT, где хранятся все адреса
виртуальных методов класса унаследованных и перекрытых, поэтому такая таблица
занимает много памяти, хотя и способ вызова метода работает сравнительно
быстро. Динамические методы вызываются медленнее, но занимают меньше памяти,
т.к. в них хранятся адреса динамических методов только данного класса и их
индексы. При вызове динамических методов проводится поиск по этой таблице, если
метод не найден, то поиск продолжается в DMT предков вплоть до Tobject, где
вызывается стандартный обработчик вызова динамических методов. Зачем же нам все
это надо? При проектировании иерархии классов предметной области, нужно
статическими делать методы, которые не меняют своего поведения в потомках, т.е.
при более детальном рассмотрении явления. Динамические и виртуальные методы
могут меняться при переходе от общего к частному. Вспомните класс Tfield,
который является общим предком для всех классов-полей таблицы. Потомки этого
класса реализуют доступ к столбикам таблицы разных типов от целого числа до
BLOB массива, однако, Вы можете иметь удобный доступ к этим потомкам через
указатель типа Tfield и работать с ними одинаково.
Перегрузка
методов, процедур и функций
Перегрузка
объявляется с помощью зарезервированного слова overload. Рассмотрим пример:
Type
TmyDateClass=class(TObject)
private
Adate: TdateTime;
…
Public
Procedure SetDate(Val: TDateTime); overload; // Объявляем возможность перегрузки
…
end;
TmySecondDateClass=class(TmyDateClass)
private
Adate: TdateTime;
…
Public
Procedure SetDate(Val: string); overload; // Объявляем возможность перегрузки
…
End;…
implementationProcedure TmyDateClass .SetDate(Val:
TDateTime);
Begin
Adate:=Val;
End;
Procedure TmySecondDateClass.SetDate(Val: string);
Begin
Adate:=StrToDate(Val);
End;
Во время работы
программы, вы можете использовать во втором классе оба метода SetDate. Если Вы передадите в качестве параметра
строку, то будет вызван метод второго класса, а если TdateTime, то метод
предка. Можно перегружать и виртуальные методы, только вместо override нужно
использовать reintroduce, например:
Type
TmyDateClass=class(TObject)
private
Adate: TdateTime;
…
Public
Procedure SetDate(Val: TDateTime); overload; virtual;
// Объявляем возможность перегрузки
…
end;
TmySecondDateClass=class(TmyDateClass)
private
Adate: TdateTime;
…
Public
Procedure SetDate(Val: string); reintroduce; overload;
// Объявляем возможность перегрузки
…
End;Вы можете использовать перегрузку и для
процедур и функций необязательно при наследовании, и даже процедур и функций не
классового типа, например:
Function Myfunction(Val: string): string; overload;
Begin
Result:=Val+' Ok!'
End;
Function Myfunction(Val: Extended): extended;
overload;
Begin
Result:=Val/2;
End;
Или
TmyDateClass=class(Tobject)
private
Adate: TdateTime;
…
Public
Procedure SetDate(Val: TDateTime); overload; // Объявляем возможность перегрузки
Procedure SetDate(Val: string); overload; // Объявляем возможность перегрузки
…
End;
Параметры по
умолчанию
Если Вам нужно
создать функцию, которая в качестве параметров почти всегда получает одно и то
же значение, но все-таки иногда оно может меняться, то Вам нужно объявить
параметры по умолчанию в качестве формальных параметров, например:
Procedure MyProcedure(Val1: Extended; Val2: Integer =
2);
Begin
…
End;
Тогда Вы
сможете вызывать ее такими способами:
MyProcedure(42.33); // аналогично MyProcedure(42.33, 2);
MyProcedure(15.6,
8);
Правило гласит,
что все параметры по умолчанию должны быть сосредоточены в конце списка
формальных параметров процедуры или функции. Опускать параметры по умолчанию,
можно только начиная с конца списка, поэтому нужно упорядочивать параметры по
умолчанию по степени важности.
Делегирование
Событие - это
свойства процедурного типа, предназначенные для создания пользовательской
реакции на внешние воздействия. События в Delphi реализуется за счет создания
поля процедурного типа и объявления соответствующего свойства класса, например:
Type
TmyEvent = procedure(Sender: Tcomponent); of object;
// определение процедурного типа
TmyClass=class(Tcomponent)
Private
FmyEvent: TmyEvent;
Protected
Procedure DoMyEvent;
published
property OnMyEvent: TmyEvent read FmyEvent write
FmyEvent;
end;
Допустим, Вы
определили функцию function MyProcedure(Sender: Tcomponent) для обработки
события с помощью инспектора объектов или написали вручную и налету присвоили
объекту: MyClass.OnMyEvent:=MyProcedure. При наступлении определенных условий
Ваш класс может вызвать процедуру DoMyEvent, где будет вызвана Ваша процедура
MyProcedure так:
Procedure TmyClass .DoMyEvent;
Begin
If Assigned(FmyEvent) then FmyEvent(Self);
End;Мы видим, что был проверен указатель на
пользовательскую процедуру обработки события, и если он действителен, то
вызывается пользовательская процедура - это и есть делегирование. Обратите
внимание, что я разместил свойство OnMyEvent в секции published для того, чтобы
программист мог воспользоваться инспектором объектов для написания процедуры
обработки события.
Список
литературы
Банников. Н.А.
Объектно-ориентированный подход к программированию.
Для подготовки
данной работы были использованы материалы с сайта www.stikriz.narod.ru
.