Одним из главных свойств ООП является инкапсуляция - замыкание в общей оболочке (Object…end) всех составляющих описания. При этом поля оказываются глобальными для методов данного объекта, т.к. у полей и методов общая область действия, то совпадение имен полей и формальных параметров методов не допустимо. Блоки-методы вынесены за описание типа объект. Имена блоков-методов, принадлежащих разным типам могут совпадать. Даже при совпадении имен заголовки методов будут различны, т.к. состоят из префикса (имени типа) и имени метода. Доступ к полям объектов из вне можно принудительно ограничивать. Для этого группа полей в описании объекта заключается в скобки Private Public. После этого поля окажутся доступными лишь методам данного модуля.
Описание объекта (как и всех прочих типов) должно содержаться в разделе описаний. Данные, которые содержит объект, называются полями объекта. Описание простейшего объектного типа очень похоже на описание записи; только вместо одного зарезервированного слова (RECORD) используется другое (OBJECT).
Dot = object
a, b : integer;
Этот объектный тип, содержащий два поля, представляет собой точку на экране с координатами a и b.
§ Помимо данных в виде полей (которые могут принадлежать любому типу, в том числе и объектному), объект также может содержать подпрограммы, описывающие действия, допустимые над этими полями. Такие подпрограммы называются методами. Метод имеет доступ к полям объекта, не нуждаясь в передаче их ему в качестве параметров. Свойство объектов содержать в себе не только данные (поля), но и описание действий, допустимых над этими данными (методы), называется инкапсуляцией.
При этом непосредственно в описании объекта имеются только заголовки подпрограмм, а тело каждой подпрограммы задается отдельно. Вернемся к типу Dot из предыдущего примера. Вот как выглядит описание этого объектного типа, дополненное необходимыми методами (описание полей всегда должны предшествовать заголовкам методов).
В этом примере объект содержит четыре метода. Метод Init инициализирует объект (т.е. присваивает точке на экране некоторые начальные значения). Методы Show и Hide «зажигают» и «гасят» точку на экране. Наконец, метод Move перемещает точку по экрану.
После того как объектный тип объявлен, ничто не мешает создавать переменные этого типа, или, следуя терминологии ООП, экземпляры объекта. Это могут быть как статистические переменные, объявленные в разделе описания переменных, так и динамические, созданные с помощью стандартной процедуры New .
Dot1 : Dot;
Здесь объявлена (статистическая) переменная Dot1 (или экземпляр объекта), принадлежащая типу Dot. После того как экземпляр объекта создан, его поля становятся доступны для методов, хотя к полям объекта возможен и непосредственный доступ – как к полям записи (этого Turbo Pascal не запрещает). Для этого чтобы непосредственно применить к полю объекта какую-либо стандартную подпрограмму, достаточно воспользоваться его составным именем – указать идентификатор объекта и (через точку) идентификатор этого поля. Однако такой подход был бы отступлением от принципов объектно-ориентированного программирования (ООП). ООП при манипулировании полями объекта предполагает использование только его методов.
Dot1.Init (100,100);
Dot1.Show;
Dot1.Move (50, 50);
Так же как и к записям, к объектам применим оператор WITH.
withDot1 do begin
Init (100, 100);
Show;
Move (50, 50)
end;
Представленные выше две последовательности операторов эквивалентны.
Полный текст программы, с фрагментами которой мы только что имели дело, представлен ниже. Данная программа отображает на экране светящуюся точку (пиксель). Кроме того, отображаемую точку можно перемещать по экрану в четырех направлениях с помощью соответствующих клавиш-стрелок.
В программе объявлен уже знакомый нам объект Dot, содержащий два поля: a и b, которые определяют положение точки на экране, а также четыре метода: Init, Show, Hide и Move.
Далее следует раздел описания переменных, в котором среди прочих переменных объявлен экземпляр объекта Dot1. Тело программы начинается с операторов, обеспечивающих переход в графический режим.
Далее следует оператор REPEAT, выявляющий нажатие определенной клавиши. Оператор CASE здесь содержит четыре варианта, которые соответствуют четырем клавишам-стрелкам. Каждый из упомянутых вариантов вызывает метод Move с фактическими параметрами, обеспечивающими перемещение светящейся точки в нужном направлении и на определенном расстоянии – на пять пикселей.
Условием завершения цикла, организованного с помощью оператора REPEAT, является нажатие клавиши, генерирующей скэн-код 27 (это клавиша <Esc>). На этом завершает работу и вся программа в целом.
Перечень источников:
1. Ахо Альфред В., Хопкрофт Джон, Ульман Джеффри Д. Структуры данных и алгоритмы: Пер. с англ.: Уч.пос.- М.: Издательский дом “Вильямс”, 2000.-324 с.
2. Бауэр Ф.Л., Гооз Г. Информатика. Вводный курс: В 2 ч.- М.:Мир, 1990.-543с.
3. Вирт Н. Алгоритмы + структуры данных = программы.- М.: Мир, 1985. (Алгоритмы и структуры данных.- М.: Мир, 1989.) (Алгоритмы и структуры данных. – СПб.: Невский Диалект, 2001. (2-е изд., испр.))
Тема 4.3. Наследование.
Тип лекции: текущая
План:
1. Наследование Примитивные объекты не используются как програмные модули, а используются в качестве носителей общих свойств и методов. Такие объекты называют родительскими. Объекты основанные на родительских называют дочерними. Родительский тип не используемый для описания переменных называется абстрактным. Тип потомок наследует все поля типа отца. В их числе все поля унаследованные отцом, если у него есть предки. Увеличение числа полей у потомка необязательно. Наследоваться также могут и методы, но выборочно. Описание типа потомка имеют отличительную деталь - имя типа отца: <имя типа потомка>=object(<имя типа отца>) С увеличением сложности объектов увеличивается число действий, которое можно заменить построением нового метода, причем имена методов создаются так, как если бы объекты не имели между собой родственной связи. Одинаковое обозначение функционально-подобных методов упрощает не только восприятие системы объектов, но и программирование. Важной деталью использования наследования в программах является применение присваивания объектам значений объектов. Присваивание A:=B допустимо, если A и B - однотипны, A - предок B или для каждого поля A есть соответствующее поле в B.
Предположим, мы создаем программу, в которой, помимо объекта-точки, фигурирует также объект-окружность. Конечно, можно было бы описание этого нового типа создать с нуля, подобно тому как мы описали тип Dot в предыдущем разделе. Однако этот новый тип-окружность (назовем его Ring) имеет много общего с существующим типом Dot. В самом деле, как и точка, окружность характеризуется двумя координатами: a и b, определяющими положение ее центра. Однако для создаваемого объекта необходимо добавить поле, задающее радиус окружности.
Что касается методов, то для нового типа Ring подошел бы метод Move, поскольку перемещение точки и перемещение окружности (собственно, ее центра) по экрану осуществляются одинаково. Однако метод, инициализирующий объект (Init), а также методы, делающие окружность видимой или невидимой (Show и Hide), придется создать заново.
§ Итак, мы выяснили, что новый тип Ring кое в чем повторяет тип Dot. А нельзя ли новый тип создать на основе уже существующего, просто добавив в него новые поля и методы? Оказывается, это возможно благодаря свойству объектных типов, известному как наследование. Поскольку речь идет о наследовании, в соответствии с генеалогической терминологией существующий тип, служащий основой для создания нового объекта, называют предком, или родительским типом, а создаваемый объект – потомком, или дочерним типом. Потомок автоматически наследует все поля и методы своего предка.
§ Свойство наследования широко используется в ООП. Благодаря ему на основе существующего объекта можно создать любое количество новых объектов. Основываясь на этих новых объектах, можно создавать еще и еще объекты, причем длина цепочки наследования ничем не ограничивается. При этом каждый объект может иметь любое количество потомков, но только единственного предка.
А теперь вернемся к нашим типам Dot и Ring. В описании типа-потомка должно указываться имя родительского типа (в круглых скобках после зарезервированного слова OBJECT).
Ring = object (Dot)
Rad : integer
end;
В приведенном описании типа Ring имеется поле Rad, определяющее радиус окружности, которого не было у типа Dot. Кроме того, тип Ring унаследовал все поля своего предка (два значения типа INTEGER, определяющие положение точки на экране). Однако здесь пока отсутствуют методы. Вот как может выглядеть описание типа Ring, дополненное соответствующими методами.
Ring = object (Dot)
Rad : integer;
procedure Init (x, y, r : integer);
procedure Show;
procedure Hide
end;
{----------------------------------------------}
procedureRing.Init;
a : =x; b : =y; Rad :=r;
end;
{----------------------------------------------}
procedure Ring.Show;
SetColor (White);
Circle (a, b, Rad);
end;
{---------------------------------------------}
procedure Ring.Hide;
SetColor (Black);
Circle (a, b, Rad);
end;
§ Необходимо заметить, что методы объекта-потомка заменяют собой (или переопределяют) для потомка одноименные методы родительского объекта. Иными словами, если имеет место обращение к методу Ring.Move, система смотрит, не задан ли метод с таким именем в описании объекта Ring. Если да, используется этот новый метод; если нет, применяется метод, унаследованный от предка. (При этом необходимо помнить, что переопределять можно только методы; имена полей в объекте-потомке не должны совпадать с именами полей родительского объекта.)
После того как тип-потомок объявлен, прежде чем приступить к манипулированию его полями, необходимо создать экземпляр объекта.
ring1 : ring;
Перечень источников:
1. Ахо Альфред В., Хопкрофт Джон, Ульман Джеффри Д. Структуры данных и алгоритмы: Пер. с англ.: Уч.пос.- М.: Издательский дом “Вильямс”, 2000.-324 с.
2. Бауэр Ф.Л., Гооз Г. Информатика. Вводный курс: В 2 ч.- М.:Мир, 1990.-543с.
3. Вирт Н. Алгоритмы + структуры данных = программы.- М.: Мир, 1985. (Алгоритмы и структуры данных.- М.: Мир, 1989.) (Алгоритмы и структуры данных. – СПб.: Невский Диалект, 2001. (2-е изд., испр.))
Тема 4.4.Виртуальные методы и полиморфизм.
Тип лекции: текущая
План:
1. Виртуальные методы и полиморфизм.
Полиморфизм предполагает определение класса или нескольких классов для родственных объектных типов так, что каждому классу отводится своя функциональная роль. Методы одного класса обычно наделяются общим именем. В ситуации когда необходимо сложный метод использовать в нескольких объектах и различия в поведении объектов минимальны, возможно создание смежного сложного метода с вынесением различий в сменные подчиненные методы. Такой метод называется конструктивным полиморфизмом. Осуществляется эта идея созданием виртуальных сменных методов. В заголовке такого метода присутствует слово virtual, а для их подключения к общему методу - обращение к конструктору - блоку со специальным заголовком. constructor <имя блока> (<список формальных параметров>) К конструктору надо обращаться для каждого объекта использующего виртуальные методы. Задача: тип kom - сын типа pozicia представляет закрашенные квадраты с длиной стороны raz (в пикселах). Наследуемые поля x, y являются координатами центра квадрата. Процедура kom.zoom увеличивает (уменьшает) объект если аргумент znak>0 (znak<=0). Длина raz изменяется на 2*delt, где delt - еще один аргумент.
uses graph, crt; type pozicia = object x, y: integer; procedure init (xn, yn: integer); procedure locat (var xl, yl: integer); end; kom=object (pozicia) cvet, raz: word; procedure init (xn, yn: integer; color: word); procedure zoom (delt, znak: integer); end; procedure pozicia.init; begin x:=xn; y:=yn; end; procedure pozicia.locat; begin xl:=x; yl:=y; end; procedure kom.init; begin pozicia.init (xn, yn); cvet:=color; raz:=1; end; procedure kom.zoom; var j, d: integer; begin if znak>0 then setcolor (cvet) else setcolor (getBkcolor); for j:=1 to delt do begin if znak>0 then raz:=raz+2; d:=raz div 2; moveto (x-d, y-d); linerel (d+d, 0); linerel (0, d+d); linerel (-d-d, 0); linerel (0, -d-d); if (znak<=0) and (raz>1) then raz:=raz-2; end; end; const n=50; var j, d, r, xx, yy: integer; kvad: array [1..n] of kom; begin d:=detect; randomize; initgraph (d, r, 'c:\tp\bgi'); for j:=1 to n do kvad[j].init (random(GetMaxX), random(GetMaxY), random(GetMaxColor); repeat delay (100); j:=random (n)+1; kvad[j].zoom(random(8)+1, random(3)-1); until kepressed; closegraph; kvad[1].locat (xx, yy); write (xx, ' ', yy); readln;
Давайте вернемся к методу Move из предыдущей программы. Вот его описание.
procedure Dot . Move;
Hide;
a : =a+Da; b : =b+Db;
Show
end;
Метод Move обращается к методам Hide и Show. Смысл этих обращений очевиден: сначала объект делается невидимым на экране (вызывается метод Hide), затем перемещается (координаты точки на экране нужным образом изменяются) и, наконец, снова делается видимым (вызывается метод Show).
Но что произойдет, если метод Move в данном виде использовать в программе с двумя объектами: Dot и Ring? Вспомним, что метод Move наследуется объектом Ring от объекта Dot, а методы Hide и Show, поскольку сокрытие и показ окружности на экране осуществляется не так, как точки, в объекте Ring предопределяются. Так вот, для точки при этом никаких осложнений не возникает. Точка без проблем «гаснет», меняет координаты и затем снова «зажигается», поскольку все вызываемые здесь методы (сначала Move, а затем из него – Hide и Show) для объекта Dot являются «родными».
Что касается окружности, то при вызове метода Ring.Move система пытается обнаружить метод с таким именем в описании объектного типа Ring и, не найдя его, продолжает поиск в объекте-предке. В результате имеет место обращение к методу Dot.Move. После этого из метода Move должны быть вызваны (переопределенные) методы Ring.Hide и Ring.Show, однако этого не происходит: из унаследованного метода Dot.Move экземпляр объекта Ring1, вместо Ring.Hide и Ring.Show, вызывает одноименные методы объекта Dot. Это объясняется тем, что методы Dot.Move, Dot.Hide и Dot.Show жестко связаны, поскольку они были откомпилированы в едином контексте – объектном типе Dot. Иными словами, связь между этими методами, которая была установлена при компиляции, имеет статический характер. В этом случае также окажется перемещена точка, а не окружность.
§ Как же сделать так, чтобы методы Hide и Show вызывались в зависимости от того, экземпляр какого объекта инициировал обращение к методу Move? Здесь на помощь приходит механизм, известный как динамическое (или позднее) связывание – в отличие от статического (или раннего) связывания. Указанный механизм реализуется с помощью виртуальных методов.
§ Заголовок виртуального метода в описании объектного типа дополняется зарезервированным словом VIRTUAL. Если в потомках этого объектного типа имеются переопределяющие методы (т.е. методы с тем же именем), они также должны быть объявлены как виртуальные и при этом иметь тот же набор формальных параметров, что и метод объекта-предка.
Вот как выглядят описания объектных типов Dot и Ring с виртуальными методами.
§ (Здесь CONSTRUCTOR – это зарезервированное слово, обозначающее особый вид процедуры. Вызов виртуального метода должен быть предварен обращением к такой процедуре).
Теперь вернемся к вызову экземпляром объекта Ring1 метода Move, а из него – методов Hide и Show. Здесь сначала система обращается к методу Dot.Move (предварительно метод с таким именем ищется в описании объекта Ring, и, поскольку его здесь нет, имеет место обращение к соответствующему методу объекта-предка). После этого для перемещения окружности сначала требуется сделать ее невидимой (вызвать метод Ring.Hide), затем нужным образом изменить координаты ее центра и, наконец, отобразить окружность в новом месте на экране (вызвать метод Ring.Show). А поскольку при выполнении программы Turbo Pascal обеспечивает обращение именно к тому виртуальному методу, который определен для вызывающего объекта, из метода Dot.Move имеют место обращения к методам Ring.Hide и Ring.Show.
В заключение приведем полный текст программы, отображающей на экране точку и окружность, которые можно перемещать с помощью соответствующих клавиш.
var i, j, k, Err : integer; a : char; Dot1 : Dot; Ring1 : Ring;
begin {тело программы}
i :=detect;
InitGraph(i, j, ’’);
Err :=GraphResult;
if Err <> grOK then
Writeln (GraphErrorMsg(Err))
Dot1.Init (GetMaxX div2, GetMaxY div 2);
Dot1.Show;
Ring1.Init(GetMaxX div 2, GetMaxY div 2, GetMaxY div 6);
Ring1.Show;
while KeyPressed do a : =ReadKey;
a : =ReadKey;
case ord(a) of
72 : Dot1.Move (0,-5);
80 : Dot1.Move (0,5);
77 : Dot1.Move (5,0);
75 : Dot1.Move (-5,0);
73 : Ring1.Move (0,-5);
81 : Ring1.Move (0,5);
79 : Ring1.Move (5,0);
71 : Ring1.Move (-5,0)
end;
until a = chr (27)
end.
Данная программа отличается от программы, приведенной в этой главе выше, только тем, что здесь дополнительно объявлен тип-потомок Ring. Кроме того, методы Show и Hide обоих объектов объявлены как виртуальные, а методы Init преобразованы в конструкторы.
Кроме того, оператор CASE в новой программе дополнен следующими вариантами.
73 : Ring1.Move (0,-5);
81 : Ring1.Move (0,5);
79 : Ring1.Move (5,0);
71 : Ring1.Move (-5,0);
Представленные варианты обеспечивают перемещение окружности по экрану в четырех направлениях. Перемещение имеет место при нажатиях клавиш <PgUp> (вверх), <PgDn> (вниз), <End> (вправо) и <Home> (влево), генерирующих скэн-коды соответственно 73, 81, 79 и 71.
§ В этой программе особое внимание следует обратить на вызовы метода Move в теле оператора CASE. В первых четырех случаях имеет место обращение к методу Dot.Move, а в остальных случаях – к методу Ring.Move. Однако мы знаем, что метод Move – единственный. Он объявлен в объекте Dot и унаследован объектом Ring. Иными словами, один и тот же метод Move работает по-разному (перемещает точку или окружность) – в зависимости от того, какой объект его вызывает. Такое свойство объектов называется полиморфизмом.
Перечень источников:
1. Ахо Альфред В., Хопкрофт Джон, Ульман Джеффри Д. Структуры данных и алгоритмы: Пер. с англ.: Уч.пос.- М.: Издательский дом “Вильямс”, 2000.-324 с.
2. Бауэр Ф.Л., Гооз Г. Информатика. Вводный курс: В 2 ч.- М.:Мир, 1990.-543с.
3. Вирт Н. Алгоритмы + структуры данных = программы.- М.: Мир, 1985. (Алгоритмы и структуры данных.- М.: Мир, 1989.) (Алгоритмы и структуры данных. – СПб.: Невский Диалект, 2001. (2-е изд., испр.))
Перечень источников литературы для самостоятельного изучения учебной дисциплины «Основы алгоритмизации и программирования»
1. Алексеев А.Ю., Ивановский С.А., Куликов Д.В. Динамические структуры данных. Практикум по программированию/ ГЭТУ. СПб., 1997.
Опалева Э.А., Самойленко В.П. Технология программирования: Учеб.пособие/ГЭТУ. –С.-Пб., 1995.
2. Ахо А., Хопкрофт Дж., Ульман Дж. Построение и анализ вычислительных алгоритмов.- М.: Мир, 1979.
3. Ахо Альфред В., Хопкрофт Джон, Ульман Джеффри Д. Структуры данных и алгоритмы: Пер. с англ.: Уч.пос.- М.: Издательский дом “Вильямс”, 2000.
4. Бауэр Ф.Л., Гооз Г. Информатика. Вводный курс: В 2 ч.- М.:Мир, 1990.
5. Вирт Н. Алгоритмы + структуры данных = программы.- М.: Мир, 1985. (Алгоритмы и структуры данных.- М.: Мир, 1989.) (Алгоритмы и структуры данных. – СПб.: Невский Диалект, 2001. (2-е изд., испр.))
6. Ефимова О.Е., Морозова В., Шафрин Ю. Информационные технологии.- М.: 1998. – 457с.
7. . Майкл Ласло. Вычислительная геометрия и компьютерная графика на С++.-М.: "Издательство БИНОМ", 1997.
8. Мейер Б., Бодуэн К. Методы программирования: В 2-х томах.- М.: Мир, 1982.
9 . Пападимитриу Х., Стайглиц К. Комбинаторная оптимизация. Алгоритмы и сложность. М.: Мир, 1985.
10. Райли Д. Абстракция и структуры данных: Вводный курс.- М.: Мир, 1993.
11. Хендерсон П. Функциональное программирование. Применение и реализация. М.: Мир, 1983.
