Итак , рассмотрим во всей своей красе объектно - ориентированное программирование на паскале . Перед тем, как начать рассказывать о данной технологии, я желаю отметить принципиальные тенденции в развитии обычного (алгоритмического) программирования. Что бы было более - менее понятно сразу будем писать код реализующий ту или иную возможность
Достаточно нередко встречаются ситуации, когда создаются несколько функций и процедур, работающих с одним и этим же набором данных. К примеру, в Windows для каждого окна, что мы лицезреем на экране, имеется набор переменных, хранящих состояние этого окна: координаты как бы левого верхнего угла, размер окна и остальные характеристики. Не считая того в Windows имеются процедуры и функции для работы с окнами: показать окно, переместить окно и т.д.. Возникает мысль скооперировать "в одном флаконе" и функции, и данные, с которыми они работают. Это дозволяет, а именно, не передавать информацию о определенном окне через характеристики.
Приведу очередной иллюстративный пример. Любой из нас умеет воспользоваться телеком. На самом деле мы имеем "темный ящик" (в обозначенном выше смысле), у которого мы можем считывать текущее состояние (к примеру, номер канала), данные характеристики (к примеру цвет телека), также влиять на текущее состояние (переключать каналы, поменять громкость). Программа, написанная в объектно-ориентированном стиле соответствует последующему набору указаний:
Телевизор! Включись!
Телевизор! Переключись на 1 канал!
Телевизор! Выключи звук!
....
|
Понятие "объект"
Объектом мы будем именовать тип данных, аналогичный записи (record), с которым связан некий набор процедур и функций (именуемых способами). Для каждого объекта мы можем создавать хоть какое количество экземпляров объекта.
В итоге: в каждом экземпляре объекта есть некий набор переменных (они могут иметь разные типы), а всем экземплярам объекта, наконец, соответствует набор способов, при помощи которых происходит работа с объектом. Отлично реализованный объект будет наконец-то представлять собой "темный ящик", работа с ним будет так сказать осуществляться лишь при помощи способов.
Описание объекта в Паскале
Для описания объекта используется синтаксис, аналогичный описанию
записи:
type <имя объекта>=object
<список имён полей>: <тип полей>;
....
<список имён полей>: <тип полей>;
<объявление метода>
...
<объявление метода>
end;
|
Описание метода аналогично предварительному описанию функции (служебное
слово forward не используется).
После описания объекта описываются методы:
procedure <имя объекта>.<имя метода> <параметры>
<описание процедуры>
|
Аналогично можно описать и метод-функцию. Методы (также как и обычные
подпрограммы) могут не иметь параметров. Так как методы предназначены
для
работы с экземплярами объектов в них определена служебная переменная
Self, являющаяся псевдонимом для текущего экземпляра (фактически
Self - это скрытый параметр). Например,
обращение к полю x из метода производится так: self.x.
Если в методе нет одноимённой локальной переменной, к полям можно
обращаться
по названию, опуская Self и точку.
Первый пример объектно-ориентированного программирования
Приведём реализацию объекта "окно" (для реализации интерфейса с
помощью модуля
crt). Мы можем считать, что окно задаётся координатами левого верхнего
угла и
размерами по горизонтали и вертикали (с учётом рамки окна), а также
иметь
флаг видимости (true означает, что окно на экран выведено).
type СWindow=object
x,y: integer; {координаты окна}
lenx,leny: integer; {размеры окна}
visible: boolean; {флаг видимости}
procedure Init (x,y,lenx,leny: integer);
procedure Show;
function isVisible: boolean;
end;
procedure СWindow.Init (x,y,lenx,leny: integer);
{Задаёт начальные параметры окна}
begin
Self.x:=x;
Self.y:=y;
Self.lenx:=lenx;
Self.leny:=leny;
visible:=true;
end;
procedure СWindow.show;
{Рисует окно}
var i,j: integer;
begin
textbackground (BLUE);
gotoxy (x,y);
write ('╔'); {ALT+201}
for i:=1 to lenx-2 do write ('═'); {ALT+205}
write ('╗') {ALT+187}
for j:=y+1 to y+leny-2 do
begin
gotoxy (x,j);
write ('║'); {ALT+186}
for i:=1 to lenx-2 do write (' '); {ALT+205}
write ('║'); {ALT+186}
end;
gotoxy (x,y+leny-1);
write ('╚'); {ALT+200}
for i:=1 to lenx-2 do write ('═'); {ALT+205}
write ('╝') {ALT+188}
visible:=true;
end;
function CWindow.isVisible: boolean;
begin
isVisible:=visible;
end;
|
Для создания экземпляра данного объекта можно использовать стандартные
способы объявления переменных и создания динамических переменных.
var Window:CWindow;
begin
Window.Init (20,5,40,10);
Window.Show;
end.
|
Наследование
Важным элементом объектно-ориентированного стиля, стало быть, является наследование. Ежели, в конце концов, вспомнить уже приводившийся пример с телеком, то наследование можно проиллюстировать, рассмотрев "объект" - видеодвойку, которая наследует от телека все его характеристики, но в ней также есть и, как многие выражаются, новейшие. Также наследуюстя и способы (хотя, некие из их меняются: при включении, к примеру, нужно активировать не только лишь телек, да и плеер). Для видеодвойки характерны и свои собственные способы.
Наш пример класса CWindow можно как бы расширить, создав новейший класс CWindowText, который будет соответствовать окну с текстом (состоящим ровно из одной строчки). В данном случае нужно будет поменять способы. Ситуацию введения нового способа, который, мягко говоря, будет иметь тоже заглавие, что и унаследованный мы будем именовать переопределением.
Приведу описание нового объекта: при помощи способов.
type CWindowText=object(CWindow);
str: string;
procedure Init (x,y,lenx: integer, str: string);
procedure Show;
end;
procedure CWindowText.Init (x,y,lenx: integer, str: string);
begin
CWindow.Init (x,y,lenx,3);
Self.str:=str;
end;
procedure CWindowText.Show;
begin
CWindow.Show;
gotoxy (x+1,y+1);
write (str);
end;
|
Отмечу, что наследование отражается в тексте программы указанием
в скобках
родительского объекта после слова object. При этом методы
родительского объекта можно вызывать, указывая явно имя объекта,
которуму
принадлежит метод.
Сокрытие информации
Внутри описания полей один раз можно использовать слово private,
которое будет разделять поля на два типа. К полям, описанным выше
слова private можно обращаться из любого места программы,
а ниже - только из текущего модуля (такие поля называют скрытыми).
Отмечу, что при описании объектов стараются как можно больше
полей сделать скрытыми. Это подчёркивает самостоятельность объекта,
работа
с которым происходит только с помощью нескрытых полей и методов. Замечу,
что
даже простое присваивание полю значения часто делают с помощью метода.
Ведь,
в будущем в дополнении к этому присваиванию могут использоваться другие
операции.
|