Виртуальные методы и полиморфизм

↑

▷ Содержание

⇐ ПредыдущаяСтр 8 из 14Следующая ⇒

Переменная Self

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

Например:

type
A =class
i: integer;
constructor Create(i: integer);
begin
Self.i := i;
end;
end;

В момент вызова конструктора Create объект будет уже создан. Конструкция Self.i ссылается на поле i этого объекта, а не на параметр i функции Create. Фактически в любом нестатическом методе перед именем любого поля и методу этого класса неявно присутствует Self.

Свойства

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

property Prop: тип read имя функции чтения write имя процедуры записи;

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

function getProp: тип;
procedure setProp(v: тип);

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

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

Например:

type
Person =class
private
nm: string;
ag: integer;
procedure setAge(a: integer);
begin
if a>=0 then
ag := a
else raise new Exception('Возраст не может быть отрицательным');
end;
function getId: string;
begin
Result := nm + ag.ToString;
end;
public
...
property Age: integer read аg write setAge;
property Name: string read nm;
property Id: string read getId;
end;

var p: Person;
p := new Person('Иванов',20);
p.Age := -3; // генерируется исключение
var i: integer := p.Age;
writeln(p.Id);

Всякий раз, когда мы присваиваем свойству Age новое значение, вызывается процедура setAge с соответствующим параметром. Всякий раз, когда мы считываем значение свойства Age, происходит обращение к полю ag. Поле nm доступно только на чтение. Наконец, свойство Id осуществляет доступ на чтение к информации, находящейся в двух полях.

Обычно для доступа к полю на чтение в секции read свойства указывается именно поле, так как обычно при чтении поля никаких дополнительных действий производить не требуется.

Свойства не могут передаваться по ссылке в процедуры и функции. Например, следующий код ошибочен:

Inc(p.Age); // ошибка!

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

a := p.Age;
Inc(a);
p.Age := a;

Однако, свойства соответствующих типов можно использовать в левой части операций присваивания += -= *= /=:

p.Age += 1;

Свойства очень удобны при работе с визуальными объектами, поскольку позволяют автоматически перерисовывать объект, если изменить какие-либо его визуальные характеристики. Например, если создана кнопка b1 типа Button, то для визуального изменения ее ширины достаточно присвоить значение ее свойству Width:

b1.Width := 100;

Процедура для записи этого свойства в приватное поле fwidth будет выглядеть примерно так:

procedure SetWidth(w: integer);
begin
if (w>0) and (w<>fwidth) then
begin
fwidth := w;
код перерисовки кнопки
end
end;

Следует обратить внимание на вторую часть условия в операторе if: w<>fwidth. Добавление этой проверки позволяет избежать лишней перерисовки кнопки в случае, если ее ширина не меняется.

Индексные свойства

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

Индексное свойство описывается в классе следующим образом:

property Prop[описание индексов]: тип read имя функции чтения write имя процедуры записи;

В простейшем случае одного индекса описание индексного свойства выглядит так:

property Prop[ind: тип индекса]: тип read имя функции чтения write имя процедуры записи;

В этом случае функция чтения и процедура записи должны быть методами этого класса и иметь следующий вид:

function GetProp(ind: тип индекса): тип;
procedure SetProp(ind: тип индекса; v: тип);

Всякий раз, когда мы для объекта a, содержащего свойство Prop, выполняем присваивание a.Prop[ind] := value, вызывается процедура SetProp(ind,value), а когда считываем значение a.Prop[ind], вызывается функция GetProp(ind).

Индексное свойство, после которого добавлено ключевое слово default с последующей ;, называется индексным свойством по умолчанию и позволяет пользоваться объектами класса как массивами, т.е. использовать запись a[ind] вместо a.Prop[ind].

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

В следующем примере индексное свойство используется для закрашивания/стирания клеток шахматной доски в графическом режиме.

uses GraphABC;
const
n = 8;
sz = 50;
type ChessBoard = class
private
a: array [1..n,1..n] of boolean;
procedure setCell(x,y: integer; value: boolean);
begin
if value then
Brush.Color := clWhite
else Brush.Color := clBlack;
Fillrect((x-1)*sz+1,(y-1)*sz+1,x*sz,y*sz);
a[x,y] := value;
end;
function getCell(x,y: integer): boolean;
begin
Result := a[x,y];
end;
public
property Cells[x,y:integer]: boolean read getCell write setCell; default;
end;

var c: ChessBoard := new ChessBoard;

begin
var x,y: integer;
for x:=1 to n do
for y:=1 to n do
c[x,y] := Odd(x+y);
end.

Наследование

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

При описании класса его базовый класс указывается в скобках после слова class.

Например:

type
BaseClass = class
procedure p;
procedure q(r: real);
end;
MyClass =class(BaseClass)
procedure p;
procedure r(i: integer);
end;

В данном примере процедура p переопределяется, а процедура r добавляется в класс MyClass.

Если не указать имя базового класса, то считается, что класс наследуется от класса Object - предка всех классов. Например, BaseClass наследуется от Object.

Переопределение методов при наследовании рассматривается здесь.

Перед словом class может быть указано ключевое слово final – в этом случае от класса запрещено наследовать.

Переопределение методов

Метод базового класса может быть переопределен (замещен) в подклассах. Если при этом требуется вызвать метод базового класса, то используется служебное слово inherited (англ.- унаследованный). Например:

type
Person =class
private
name: string;
age: integer;
public
constructor Create(nm: string; ag: integer);
begin
name := nm;
age := ag;
end;
procedure Print;
begin
writeln('Имя: ',name,' Возраст: ',age);
end;
end;
Student =class(Person)
private
course, group: integer;
public
constructor Create(nm: string; ag,c,gr: integer);
begin
inherited Create(nm,ag);
course := c;
group := gr;
end;
procedure Print;
begin
inherited Print;
writeln('Курс: ',course,' Группа: ',group);
end;
end;

Здесь метод Print производного класса Student вызывает вначале метод Print, унаследованный от базового класса Person, с помощью конструкции inherited Print. Аналогично конструктор Create класса Student вызывает вначале конструктор Create базового класса Person, также используя служебное слово inherited.

Правила наследования конструкторов рассматриваются здесь.

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

Если в методе вызывается метод базового класса с теми же параметрами, то можно использовать запись inherited, не указывая имя метода и параметры. Например, метод Student.Print можно записать таким образом:

procedure Print;
begin
inherited;
writeln('Курс: ',course,' Группа: ',group);
end;

Наследование конструкторов

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

В PascalABC.NET принято промежуточное решение. Если класс не определяет конструкторов, то все конструкторы предка автоматически генерируются в потомке, вызывая соответствующие конструкторы предка (можно также говорить, что они наследуются). Если в классе определяются конструкторы, то конструкторы предка не генерируются. Конструктор по умолчанию, если он явно не определен, генерируется автоматически в любом случае и является protected.

Кроме того, в .NET обязательно в конструкторе потомка первым оператором должен быть вызван конструктор предка; в Object Pascal это необязательно. Если в PascalABC.NET конструктор предка вызывается из конструктора потомка, то этот вызов должен быть первым оператором. Если конструктор предка явно не вызывается из конструктора потомка, то неявно первым оператором в конструкторе потомка вызывается конструктор предка по умолчанию (т.е. без параметров). Если такого конструктора у предка нет (это может быть класс, откомпилированный другим .NET-компилятором или входящий в стандартную библиотеку классов - все классы, откомпилированные PascalABC.NET, имеют конструктор по умолчанию), то возникает ошибка компиляции.

Например:

type
A = class
i: integer;
// конструктор по умолчанию не определен явно, поэтому генерируется автоматически
constructorCreate(i: integer);
begin
Self.i := i;
end;
end;
B =class(A)
j: integer;
constructorCreate;
begin
// конструктор по умолчанию базового класса вызывается автоматически
// конструктор по умолчанию определен явно, поэтому не генерируется автоматически
j := 1;
end;
constructorCreate(i,j: integer);
begin
inherited Create(i);
Self.j := j;
end;
end;
C =class(B)
// класс не определяет конструкторов, поэтому
// конструктор по умолчанию и constructorCreate(i,j: integer)
// генерируются автоматически, вызывая в своем теле соответствующие конструкторы предка
end;

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

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

Для пояснения рассмотрим переопределение метода в подклассе:

type
Base =class
public
procedure Print;
begin
writeln('Base');
end;
end;
Derived =class(Base)
public
procedure Print;
begin
writeln('Derived');
end;
end;

Присвоим переменной базового класса Base объект производного класса Derived и вызовем метод Print.

var b: Base := new Derived;
b.Print;

Какая версия метода Print вызывается - класса Base или класса Derived? В данном случае решение будет принято еще на этапе компиляции: вызовется метод Print класса Base, заявленного при описании переменной b. Говорят, что имеет место раннее связывание имени метода с его телом. Если же решение о том, какой метод вызывать, принимается на этапе выполнения программы в зависимости от реального типа объекта, на который ссылается переменная b, то в данном случае вызывается метод Derived.Print (говорят также, что имеет место позднее связывание). Методы, для которых реализуется позднее связывание, называются виртуальными, а переменная базового класса, через которую осуществляется вызов виртуального метода, - полиморфной переменной. Таким образом, полиморфизм реализуется вызовом виртуальных функций через переменную базового класса. Тип класса, который хранится в данной переменной на этапе выполнения, называется динамическим типом этой переменной.

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

type
Base =class
public
procedure Print; virtual;
begin
writeln('Base');
end;
end;
Derived =class(Base)
public
procedure Print; override;
begin
writeln('Derived');
end;
end;

Теперь в аналогичном участке кода.

var b: Base := new Derived;
b.Print;

вызывается метод Print класса Derived за счет того что решение о вызове метода откладывается на этап выполнения программы.

Говорят, что методы Print завязаны в цепочку виртуальности. Чтобы разорвать ее (не вызывать методы в подклассах виртуально) используется ключевое слово reintroduce:

type
DerivedTwice1 =class(Derived)
public
procedure Print; reintroduce;
begin
writeln('DerivedTwice1');
end;
end;

Если мы хотим начать новую цепочку виртуальности, то следует использовать и virtual и reintroduce:

type
DerivedTwice2 =class(Derived)
public
procedure Print; virtual; reintroduce;
begin
writeln('DerivedTwice2');
end;
end;

Если переопределить виртуальную функцию невиртуальной без ключевого слова reintroduce, то ошибки не произойдет - будет выведено лишь предупреждение о том, что цепочка виртуальности нарушена. Таким образом, ключевое слово reintroduce в этой ситуации лишь подавляет вывод предупреждения.

При переопределении виртуального метода в подклассе его уровень доступа должен быть не ниже, чем в базовом классе. Например, public виртуальный метод не может быть переопределен в подклассе private-методом.

Познавательные статьи:



Организация работы процедурного кабинета

Статус республик в составе РФ

Понятие финансов, их функции и особенности

Сущность демографической политии