Объектно Ориентированное Программирование. Хорошая книга для Хороших Людей

. . 
 
 
 

 
 
 
 
 
 
 
 
-2020 

681.3 
32.973-18 
     63 
 
 
. .  
    . . — .: -, 2020. — 298 .: .  
 
ISBN 978-5-91359-138-8 
 
() — , , .  
, , . 
, , - , , . 
, — . 
, , . . 
 
 
 
 
— «-» () . : 
1. : 123001, , /82. 
2. www.solon-press.ru «— ». 
3. . (495) 617-39-64, (495) 617-39-65. 
. 
, , , . . 

«-», www.solon-press.ru/kat.doc. 
-www.solon-press.ru. 
 

 
 
: 
«-» 
: (499) 725-54-09, 725-50-27, 
www.alians-kniga.ru 
 
 
 
 
 
 
 
 
 
 
 
© . ., 2020 
ISBN 978-5-91359-138-8 
 
 
 
 
© «-», 2020 
 

Посвящается 
естественно, Хорошим Людям 
Нас так мало осталось 

Содержание 
 
 
Вступление .......................................................................................................7 
Здравствуйте, коллеги!..............................................................................7 
Человеческими словами - о чём эта книга?.............................................8 
А о чём я здесь не буду говорить?............................................................9 
А на каком языке мы будем программировать?....................................11 
О шрифтах ................................................................................................13 
О Приложении и приложениях...............................................................14 
Почему я иногда повторяюсь?................................................................15 
Что почитать?...........................................................................................16 
Часть Первая. Теория ..................................................................................20 
Глава 1 TP. Простая программа. И как будто ничего нового ..............20 
Преамбула.................................................................................................20 
Повторение пройденного. Светофор без затей .....................................20 
Светофор причёсанный ...........................................................................24 
Печальное будущее нашего светофора. Прогноз..................................26 
Много, очень много, светофоров............................................................28 
Глава 2 То же самое. Весело и с объектами .............................................41 
Вступление и объяснения........................................................................41 
Наконец, объектный светофор................................................................45 
А теперь много объектных светофоров .................................................54 
А теперь со всей этой фигнёй мы попытаемся взлететь ......................59 
Глава 3 То же самое. Delphi. Глава очень короткая...............................61 
Расширение кругозора. Вообще о классах в Delphi..............................65 
Ещё раз, другими словами, о важном ....................................................67 
Виноват, исправлюсь…...........................................................................69 
Глава 4 Речь в данной главе пойдет только и исключительно о 
свойствах ........................................................................................................70 
Просто свойства .......................................................................................70 
Наконец, последняя, и правильная, светофорная программа ..............80 
Не просто свойства, а индексированные ...............................................81 
Дайте две! .................................................................................................90 
Самый главный метод .............................................................................96 
Всё-таки графика......................................................................................98 
А дальше? ...............................................................................................101 
Всякие дополнительные мелочи и детали ...........................................102 
Глава 5 Теперь по научному. Инкапсуляция ........................................106 

Глава 6 Понятная программа про наследование без терминов.........110 
Простой класс, ничего нового ..............................................................110 
Тот же класс, но кое-что новое.............................................................115 
Глава 7 Теперь по научному. Наследование..........................................122 
Общая теория. Длинная.........................................................................122 
Нюансы. Повысить или понизить?.......................................................129 
Серьёзные изменения в классе .............................................................132 
А теперь о хорошем...............................................................................136 
Глава 8 Практические занятия по наследованию.  
И по тестированию .....................................................................................139 
Небольшой перерыв – открытые массивы...........................................139 
Назад в ООП...........................................................................................143 
Вперёд в ООП.........................................................................................148 
Немного о тестах....................................................................................153 
Возвращаемся от тестирования к программированию.......................160 
ООП продолжается................................................................................163 
А теперь о главном ................................................................................168 
Развитие темы.........................................................................................173 
Глава 9 Наследование очень коротко.....................................................175 
Глава 10 Что-то с виртуальными методами..........................................178 
Сначала о грустном................................................................................178 
Любимый пример, с небольшими изменениями.................................179 
Несколько новых слов...........................................................................186 
Быстро чиним программу о словах ......................................................189 
Немного глубже и подробнее ...............................................................190 
Развитие темы.........................................................................................198 
Глава 11 Теперь по научному. Полиморфизм.......................................201 
Развитие темы.........................................................................................202 
Глава 12 Вся теория вместе и коротенько. Раз и навсегда .................205 
ООП с птичьего полёта .........................................................................205 
Наследование..........................................................................................206 
Полиморфизм .........................................................................................210 
Глава 13 Коротко. Особенности ООП применительно к Delphi........212 
О свойствах, неупомянутое...................................................................213 
Экзотика..................................................................................................215 
Глава 14 Эскиз очень сложной программы. Карты.............................216 
Преамбула...............................................................................................216 
Чего я хочу. Обоснование .....................................................................216 
Как я это вижу, и кто у нас будет классом ..........................................219 
Карта и колода. Начинаем программировать......................................224 

Рекомендации по дальнейшему развитию сюжета.............................225 
Глава 15 Эскиз программы. Пускай умрёт слабейший.......................227 
О программировании, амёбах и Чарльзе Дарвине..............................227 
Наш Мир. И наша Война.......................................................................228 
Суровая программистская реальность.................................................231 
Ободряющий финал...............................................................................235 
Часть вторая. Практика ............................................................................236 
Приложение A. Немного о карточных играх.........................................236 
Постановление Министерства спорта и туризма Республики Беларусь 
от 14 мая 2003 г. №12 "Об утверждении Инструкции по игре в "Храп"
.................................................................................................................236 
Адаптация правил храпа к нашим условиям, моим вкусовым 
пристрастиям и удобству программирования.....................................240 
Приложение B. Как настроить Delphi.  Очень коротко.......................242 
Project\Options… ....................................................................................242 
Environment Options...............................................................................244 
Editor Options..........................................................................................245 
Debugger Options....................................................................................245 
Ещё ..........................................................................................................245 
И совсем напоследок .............................................................................246 
Приложение C Как рисовать в TP. На одной странице.  
Нет, на двух ..................................................................................................247 
Приложение D. Как рисовать в Delphi....................................................249 
Цвет .........................................................................................................249 
Рисуем.....................................................................................................250 
Приложение E Простой объект для работы с клавиатурой через 
BIOS...............................................................................................................261 
Приложение F Программа о словах. Полностью и даже лучше ........263 
Комментарии, возможно, ненужные....................................................269 
О файлах и потоках. Сравнительный анализ.......................................270 
Приложение G Очень полезные процедуры, функции и классы ......277 
Правильный TStringList.........................................................................277 
Правильный TList ..................................................................................278 
Очень правильный класс для сохранения и восстановления вообще283 
Реализация правильного класса............................................................291 
Хочется чего-то ещё ..............................................................................296 
 

Вступление 

Здравствуйте, коллеги! 

Как-то раньше   я написал книгу «Самоучитель игры на Паскале». 
Потом я написал книгу «Школа игры на Паскале». Сначала всё было 
просто – сначала Самоучитель, потом Школа. А что дальше я даже и не 
знаю. Короче говоря – эта книга о самом главном – об Объектно 
Ориентированном 
Программировании. 
Сокращённо 
ООП. 
Для 
любителей, 
ООП 
можно 
расшифровать 
и 
как 
Объектно 
Ориентированный Подход. Ещё встречается расшифровка Объектно 
Ориентированное Проектирование. Смысл-то всё равно один. 
 
Сначала этот раздел назывался совсем по-другому – «Здравствуйте, мои 
маленькие друзья!». Назывался он так дурашливо и бесцеремонно 
потому, что сначала я ориентировал книгу на студентов младших 
курсов соответствующих специальностей и даже на очень умных 
старшеклассников. Но, пока я книгу писал, я много общался с другими 
программистами. А также вспоминал те чудные времена, когда 
Объектное Программирование только появилось на нашем горизонте.  
 
И, к своему ужасу, я понял, что большинство программистов ООП не 
понимают. Причём, половина программистов не понимает ООП 
вообще, но понимает, что она (половина в смысле) его (ООП в смысле) 
не понимает. А из другой половины многие уверены что всё понимают, 
но в реальности понимают как-то странно…  Эти, кстати, самые 
опасные, если с ними приходится работать вместе. 
 
Поэтому я подумал и решил слегка сменить ориентацию – на 
профессионалов, которые все-таки, наконец, захотели узнать, что же 
такое ООП и как оно работает и зачем это надо. Разумеется, студенты, и 
умные старшеклассники никуда не делись. Я вообще-то пишу очень 
просто, доступно и увлекательно. Понятно ведь – сам не похвалишь, 
никто не похвалит… 
 
И название у книги сначала было другим. Вначале эта книжка 
называлась «Объекты, классы и Винни-пух», что, разумеется, совсем 
другое дело… Потом я испугался. Не нарушаю ли этим авторских прав 
покойных А.Милна и Г.Заходера? Точнее, их покойных родственников. 
Точнее, наоборот. Ну, вы поняли. То есть я испугался, что чёрной–
чёрной ночью на чёрных-чёрных вертолетах за мной прилетят 

поборники авторских прав и впердолят. Извините, если слово 
«поборники» оказалось для вас незнакомым и грубым. Поборники – это 
такие не совсем хорошие люди, ну вы поняли, им бы лишь побороться,  
или побираться, они ведь такие поборники.  
 
Короче, название пришлось поменять. Разумеется, из-за этого 
пришлось поменять всю концепцию книги. Низабудунипрощу! 
 
Вы ничего не поняли? Хорошо, переходим ко второму разделу. 
 
Человеческими словами - о чём эта книга? 

Самокритично признаюсь – я человек немолодой и вообще скорее 
преклонных лет, чем юный. За свою жизнь я повидал немало 
нововведений, и, обычно, глядя на них,  я приговаривал – «какая 
дурь!». И обычно оказывался прав. Знаете ли вы, что такое «тощие 
компьютеры»?  Или язык программирования Жаба, которая заменит все 
дожабные языки программирования на свете? Или Интернет, который 
«всему научит сам»?  Я даже не вспоминаю о системах команд RISC, 
SISC, PISC и о безжалостной между ними войне. 
 
А знаете ли вы, что такое Open Source? Нет, вы, скорее всего, знаете, 
что это такое. Но вы наверняка и представить не можете, как нам его 
пытались 
продать 
двадцать 
лет 
назад. 
Как 
сейчас 
помню, 
замечательную статью молодого журналиста, по забавной случайности 
из того же города, что и я. Он романтически сравнивал Open Source с 
долгожданной весной – вот придёт весна, растает снег, и из-под снега 
покажутся собачье дерьмо и окурки. Придётся понюхать, но потом мы 
всё это уберём, и настанет счастье. Меня эта концепция как-то сразу не 
увлекла. 
 
А теперь нам пытаются продать какие-то «облачные вычисления», или 
что-то другое «облачное». Был такой великий поэт Маяковский, 
написал поэму «Облако в штанах», потом понял, что полная ерунда 
получается, и застрелился, от большой любви, конечно. И с этими 
нынешними фантазёрами то же будет.  
 
И вот всё, о чем я говорил, тощие компьютеры, открытые тексты и даже 
не помню точно что, отправилось, извините, в задницу. И всё прочее, 
чего я не способен понять в течение минуты, отправится туда  же. У 
меня страшное врождённое чутьё на мутные и сомнительные вещи. 

Если я чего-то за минуту не смог понять, значит «в топку», как 
говорили в моей молодости в этом самом ФИДО. Извините, отвлёкся. 
 
Так вот, одна из тех немногих вещей, которые, я мало того, что понял 
сразу, но они ещё и оказались хоть к чему-то годными – Объектно 
Ориентированное Программирование, сокращённо, как уже не раз 
сказано, – ООП. Я его рекомендую, а моя рекомендация чего-то да 
стоит. Вот о нём, об ООП, в книге в основном речь и пойдёт. 
 
 
А о чём я здесь не буду говорить? 

Вопрос кажется странным. Естественно, количество предметов 
неупомянутых в этой книге в бесконечное количество раз превышает 
количество предметов, в этой книге упомянутых. Тем не менее, вопрос 
вполне нормален и уместен – любой автор должен чем-то себя 
ограничить, за счёт предметов, которые вроде бы принадлежат к тем, о 
которых поговорить можно,  но вроде бы и ни к чему. Ни к чему, 
разумеется, исключительно по моему мнению. 
 
Так вот, я не буду говорить об этом. 
 
Я не буду говорить о том, как оно, ООП, устроено внутри. К примеру, 
вот так. Далее цитата из очень хорошей книги: 
 
«Когда компилятор компилирует правила объекта Point, он сначала 
встречает Point.Show и Point.Hide и компилирует  код  для  обоих  
правил в сегмент кода. Немного позднее в файле он встречает правило 
Point.MoveTo, которое вызывает как правило, Point.Show, так и 
правило Point.Hide. Как и в случае с любым вызовом процедуры, 
компилятор замещает указатели исходного кода на Point.Show. и 
Point.Hide адресами их сгенерированного кода в сегменте кода». 
 
Вам это интересно? Лично мне – нет. Весь смысл Объектно 
Ориентированного Подхода к программированию и заключается в том, 
что нам абсолютно неинтересно, что там внутри, причём, неважно у 
кого внутри. 
 
Древняя английская мудрость гласит: «Если оно выглядит как утка, 
плавает как утка и крякает как утка, то это утка и есть». Да, я в курсе, 
что эта мудрость не древняя и не английская, но в отношении ООП она 

заиграла новыми красками – ну кому какая разница, как оно устроено 
внутри, и как компилятор генерирует код. Крякает? Крякает. Значит, 
утка. 
 
Более того, в этой книге я ни разу не вспомню о святом: 
 
«Каждый  тип  объекта имеет в сегменте данных нечто, 
называющееся "Таблицей виртуальных правил" (VMT). Эта таблица 
содержит размер типа объекта, и, для каждого  из его  виртуальных 
правил, указатель на код, реализующий это правило. 
Конструктор же устанавливает связь  между  экземпляром,  
вызывающим этот  конструктор, и Таблицей виртуальных правил 
(VMT) данного типа объекта. 
 Важно помнить: для каждого типа объекта существует только одна 
таблица виртуальных правил. Отдельные экземпляры типа объекта 
(то есть переменные этого типа) содержат связь с VMT - они не  
содержат саму  Таблицу виртуальных  правил (VMT)».  
 
Я привёл эту длинную цитату из той же очень хорошей книги 
неслучайно. Кстати, все ссылки на источники цитирования далее 
аккуратно последуют. Я привёл эту цитату, потому что нет ни одной 
книги по ООП, в которой бы не упоминалась Таблица Виртуальных 
Методов. (Здесь, по прихоти переводчика-затейника,  то, что обычно 
называется  «метод», упорно именуется термином «правило», я не знаю 
почему). 
 
Так что я решил не отступать от всеобщего заговора писателей про 
ООП и тоже об этом вспомнил – первый и последний раз. Да и вы 
теперь всё об этом прочитали и знаете. 
 
Прочитали – забудьте. Нам это не понадобится. 
 
И, разумеется, немного далее я приведу список самых разных книг, 
которые советую вам прочитать. А вот здесь, на этом самом месте, я 
должен торжественно объявить, что есть и книги, которые читать не 
надо, что, по-своему, вполне логично. Чем хороша эпоха Интернета, так 
это тем, что можно посоветовать любую книгу, не заботясь о её годе 
выпуска. Только один пример, ничего личного. 
 
Орлик С. В. - Секреты Delphi на примерах, «Бином» 

Вот эту книгу читать не надо. Мудрость автора бесконечна и 
беспредельна, он не задумываясь даёт ответы на такие вопросы, 
которые я даже не догадался бы и задать. Кроме шуток. Вы узнаете о 
Delphi вообще, и о его компонентной модели, и  том, как устроены 
компоненты и классы изнутри то, что никто не знал, не знает, и не 
узнает. Если вам это интересно – прочитайте. С моей точки зрения – это 
типичный «Неуловимый Джо». 
 
Книга уникальна, сейчас таких уже не пишут. 
 
К этой же категории относятся и книги, их, впрочем, немного, по 
программированию собственных компонентов для Delphi. Если вы 
прочитаете хоть одну такую книгу от начала до конца и всё в ней, от 
начала, до конца, поймёте, то получите полное право и почётную 
обязанность вот прямо сейчас идти и преподавать Дельфи. Может быть, 
даже за деньги. 
 
А на каком языке мы будем программировать? 

Я человек старый, всё видел, всё знаю и во всём уверен. Поэтому, с 
высоты прожитых лет, бодро отвечаю – а какая разница! Значит, 
программировать мы будем полностью, только, и исключительно на 
Delphi. Ведь я уже сказал – какая разница! 
 
Всё же, одну программу мы напишем на Турбо Паскале. Зачем? Чтобы 
сравнить жизнь до ООП и жизнь после ООП. Потому что эту 
программу мы напишем сначала как бы на Turbo Pascal 5.0, в котором 
объектов не было,  а потом как бы Turbo Pascal 5.5, в котором эти самые 
объекты вдруг появились. А почему «как бы»? А потому что 
программировать всё равно будем на Turbo Pascal 7.0. Его легче всего 
найти. 
 
Если вам кажется это излишним, то вы неправы. 
 
//  Честное признание  
Когда я сказал, что одну программу мы всё-таки напишем на Турбо 
Паскале, я немного соврал. Мы действительно напишем одну 
программу (о светофорах) на Турбо Паскале, Только мы напишем её 
сначала без объектов, а потом ещё раз, но теперь с объектами. А ту, 

которая без объектов, мы напишем сначала для одного светофора, а 
потом для целой их, светофоров, совокупности.  
//  конец Честного признания 
 
Ещё есть такой то ли язык, то ли среда программирования (IDE) Pascal 
ABC, 
разработанный 
отечественными 
авторами 
с 
механикоматематического 
факультета 
Ростовского 
государственного 
университета. По ряду причин в моей книге «Самоучитель игры на 
Паскале» этому языку уделено значительное внимание. Я бы, конечно, 
сказал с уверенным видом, что эта среда неперспективна, но в данном 
случае моего мнения никто не спрашивал. Поддержка и развитие этой 
штуковины прекратилась за пять лет до того, как я  о ней в первый раз 
услышал. 
 
В  любом случае, этот продукт принципиально ориентирован на 
создание исключительно учебных программ. 
 
 «Зачем нам кузнец? Кузнец не нужен» - (С) старый советский фильм 
«Формула любви». 
«Скрипач не нужен» - (С) старый советский фильм «Кин-Дза-Дза».  
 
Pascal ABC не будет. Там всё то же самое, только гораздо хуже. Верьте 
мне. Я знаю. 
 
А здесь я отвечаю на главный вопрос? А почему не C++? Чем C++ 
хуже? Или, я готов поставить вопрос жёстко и бескомпромиссно – 
почему Delphi лучше? 
 
Свою точку зрения я повторял много раз, во разных статьях, 
выступлениях, апробациях и даже книгах. И, мне совсем не трудно, я 
повторю снова. Язык C+ замечательный язык для программистов выше 
среднего и вообще высокого уровня. Да, врать не буду, мне тоже 
иногда хочется писать программу в традиционном чукотском стиле 
«Что вижу, то пою». Меня часто утомляет необходимость переводить 
указатель в целое число, прибавлять к числу смещение, переводить 
целое число снова и обратно в указатель, затем разъименовывать этот  
указатель, после приводить полученный разъименованный указатель в 
тип, чаще всего, записи, и, наконец,  извлекать уже оттуда 
интересующее меня поле.  
 

Но, я понимаю, что это относительно недорогая плата за страх, точнее, 
плата за отсутствие страха. Большинство моих ошибок будут 
отловлены ещё транслятором, а когда я вижу того синтаксического 
монстра, которого я только что описал, я внутренне напрягаюсь и ищу в 
этом месте программы долгожданную и предсказуемую ошибку.  
 
Математический текст такого стиля (вдохновлённый, несомненно, 
дьяволом) не может не содержать опечаток. 
Дж. Литлвуд «Математическая смесь».  М, «Наука» ,1976 
 
Такой текст, неважно математический или программный,  просто 
создан для ошибок. Разница в том, что в Delphi эти места сразу 
бросаются в глаза, а в C++ выглядят как неотъемлемая и гармоничная 
часть программного кода. Кстати, загляните в книгу Литлвуда. Она 
небольшая, и хоть что-то в ней вам обязательно понравится.  
 
А почему Дельфи 7, а не выше? А потому, что мы здесь учимся не 
программировать на Дельфи. Мы пытаемся понять, что такое Объектно 
Ориентированное Программирование на примере Дельфи. Версия 
Delphi 7 для наших целей подходит очень хорошо – все ООП 
особенности в язык программирования уже добавлены, но язык этот 
ещё не ушёл куда-то налево. 
 
О шрифтах 

Всё очень просто. Если в тексте попадается слово, выделенное жирным 
шрифтом (извините, полужирным), то это совсем не потому, что оно, 
это слово, кажется мне чрезвычайно важным. Это по той примитивной 
причине, что Delphi или  Turbo Pascal автоматически выделяют это 
слово как зарезервированное.  
 
А если буковки будут маленькие, а точнее, Courier New 12,  то значит, 
это 
исходный 
код 
программы, 
а 
правило 
о 
выделении 
зарезервированных 
слов 
продолжает 
действовать, 
они 
будут 
маленькими, но жирными, вот так: 
 
function Chtoto.GetR(     ind : integer) 
begin 
 
result:=fR[ind] 
end;