§10.2. Свойства объектов
Любой язык объектно-ориентированного программирования характеризуется тремя основными свойствами.
1. Инкапсуляция – это определение записей с методами, то есть процедурами и функциями, работающими с полями этих записей, которое формирует новый тип данных – объект.
2. Наследование – определение объекта и дальнейшее использование всех его свойств для построения иерархии порожденных объектов с возможностью для каждого порожденного объекта, относящегося к иерархии, доступа методам и данным всех порождающих объектов.
3. Полиморфизм – присваивание определенному действию одного имени, которое затем совместно используется по всей иерархии объектов, причем каждый объект иерархии выполняет это действие характерным именно для него способом.
Технически инкапсуляция выполняется следующим образом. Непосредственно в описании типа задаются только заголовки подпрограмм-методов, а описания подпрограмм записываются отдельно, аналогично модулям. Имя, и соответственно обращение к методу, формируется аналогично обращению к полям записей: указывается имя объектного типа, а через точку-разделитель – имя подпрограммы-метода. Например, точка на экране может быть описана следующим образом:
Type
Point = object
X, Y: integer;
Visible: boolean;
Procedure Create (a, b: integer);
Procedure SwitchOn;
Procedure SwitchOff;
Procedure Move (dx, dy: integer);
Function GetX: integer;
Function GetY: integer;
End;
Procedure Point.Create (a, b: integer);
Begin
X := a; Y := b;
Visible := False;
End;
Procedure Point.SwitchOn;
Begin
Visible := True;
PytPixel (X, Y, GetColor);
End;
…
Function Point.GetX: integer;
Begin
GetX := X;
End;
…
Такое разделение диктуется, во-первых, необходимостью достижения большей наглядности определения объектов, во-вторых, становится возможным определение такого типа как интерфейсного элемента модуля. В этом случае реализация методов объекта будет размещена в соответствующем разделе.
Таким образом, объединение в одном имени информации о некотором реальном объекте (в примере – точке на экране монитора) и операциях над ним делает объектный тип замкнутым самодостаточным элементом, содержащим все требуемые знания о конкретном объекте. Имея такое описание, можно определять в программе экземпляры объектов, например:
Var
OnePoint: Point;
и в дальнейшем оперировать с этим экземпляром посредством его методов:
OnePoint.Create (100, 200);
OnePoint.SwitchOn;
OnePoint.Move (20, -10);
Для объектов, как и для записей, можно использовать оператор присоединения With, например:
With OnePoint do Begin
Create (100, 200);
SwitchOn;
Move (20, -10);
end;
Свойство наследования объектных типов позволяет при построении нового типа использовать ранее определенный объектный тип, что существенно экономит объем текста программы. Например, пусть необходимо построить объектный тип для круга на экране монитора. Структура информации для него очень похожа на структуру для точки: здесь также необходимы поля Х и Y для фиксации центра круга и логическое поле Visible для определения видимости круга в текущий момент. Кроме этого необходимо задавать радиус круга.
При традиционном процедурном стиле программирования можно или ввести для круга совершенно новую структуру, или сконструировать структуру, используя в ней поля ранее определенного типа, то есть сделать «структуру в структуре». Хотя оба подхода приемлемы, но объектно-ориентированное программирование предлагает иной, более предпочтительный подход.
В Турбо Паскале при определении типа потомка после служебного слова object должно быть указано имя родительского типа, например:
Type
Circle = object (Point)
Radius: integer
end;
Это означает, что в объектном типе Circle присутствует не только поле Radius, но неявно и все поля из типа Point, включая и методы:
Var
OneCircle: Circle;
Begin
…
OneCircle.Create (100, 200);
OneCircle.Radius := 30;
…
Тип-потомок может, в свою очередь, выступать как предок по отношению к другому объектному типу, например, определение фигуры «кольцо», состоящей из двух концентрических кругов:
Type
Ring = object (Circle)
Radius2: integer
end;
Здесь так же наследуются поля и методы типа Point, который считается косвенным предком для Ring. Длина такой цепочки не ограничена.
В примере с объектным типом Circle он имеет в своем составе методы объекта-предка Point. Но если методы получения координат центра GetX и GetY здесь можно использовать без изменений, то для рисования круга методы SwitchOn и SwitchOff неприменимы. Наиболее простым решением было бы ввести в новый тип и новые методы с новыми именами. Но объектно-ориентированный подход с использованием свойства полиморфизма позволяет определить новые методы со старыми именами, переопределив тем самым методы типа-родителя:
Type
Circle = object (Point)
Radius: integer;
Procedure Create (a,b,R: integer);
Procedure SwitchOn;
Procedure SwitchOff;
Procedure Move (dx,dy: integer);
Function GetR: integer;
end;
…
Procedure Circle.Create (a,b,R: integer);
Begin
Point.Create (a,b);
Radius := R
end;
…
Procedure Circle.SwitchOn;
Begin
Visible := True;
Graph.Circle (X,Y,Radius)
end;
…
Function Circle.GetR: integer;
Begin
GetR := Radius
end;
…
Так как стандартная процедура для рисования круга из модуля Graph так же имеет имя Circle, то для ее однозначной идентификации необходимо использовать составное имя Graph.Circle.
Это определение содержит следующие элементы:
Унаследованные поля X, Y, Visible;
Собственное поле Radius;
Унаследованные без изменения методы GetX, GetY;
Новый собственный метод GetR;
Полностью переопределенные методы Circle.SwitchOn, Circle.SwitchOff и Circle.Move;
Частично переопределенный метод Circle.Create. Для инициализации полей X, Y, Visible используется унаследованный метод Point.Create, но для инициализации поля Radius метод расширен.
Замечание 1. К полям любого объекта можно обращаться и напрямую, например, без использования процедуры Circle.Create, функции GetR и других. Но является правилом хорошего стиля программирования обращение ко всем полям только с помощью методов данного объекта, то есть поля считаются скрытыми.
Замечание 2. Переопределять можно только методы. Поля, указанные в родительском типе, наследуются безусловно и не могут быть переопределены, то есть имена полей типа-потомка не должны совпадать с именами полей типа-предка. Кроме того, переопределенный метод может иметь совершенно другие параметры в отличие от метода-предка.
Раннее и позднее связывание
Рассмотрим объектные типы Point и Circle. Они связаны отношением наследования и содержат, наряду с другими, методы SwitchOn, SwithOff и Move. Первые два из них реализуют алгоритмы рисования и удаления фигуры с экрана, они существенно различны для разных типов. Алгоритм же метода Move практически одинаков для обоих типов: удаление фигуры со старого места, изменение ее координат и рисование на новом месте. Например:
Procedure Move (dx, dy: integer);
Begin
SwitchOff;
X:=X+dx;
Y:=Y+dy;
SwitchOn;
end;
Рассмотрим вариант унаследования этого метода без переопределения. Пусть имеются экземпляры двух разных объектов:
Var
OnePoint: Point;
OneCircle: Circle;
то вызовы методов
OnePoint.Move (10, -20);
OneCircle.Move (10, -20);
приведут к одному и тому же действию: перемещению точки. Это связано с тем, что экземпляр типа-потомка вызывает унаследованный метод Move, который жестко связан с методами Point.SwitchOn и Point.SwitchOff на ранней стадии, то есть еще во время компиляции программы. В данном случае связь методов является статической.
Для того, чтобы в полной мере использовать свойство полиморфизма и использовать одни и те же унаследованные методы, по-разному применяемые к разным объектам, необходимо, во-первых, разорвать связь метода Move с методами предка Point, во-вторых, обеспечить возможность вызывать разные методы SwitchOn и SwitchOff в зависимости от того, какой объект вызывает Move.
Это можно реализовать только во время вызова метода, то есть в процессе выполнения программы, поэтому такой механизм называется динамическим или поздним связыванием и достигается введением виртуальных методов.
|
