Пратт Т. Языки программирования. Разработка и реализация

Подождите немного. Документ загружается.

315

int i;

read(i); – Ïîëó÷àåì öåëî÷èñëåííîå çíà÷åíèå äëÿ i

x.ToElem(i); – Ïðåîáðàçóåì x ê òèïó elem

y.push(x); – Ïîìåùàåì x â ñòåê y

…

}

Этот пример иллюстрирует некоторые важные аспекты использования клас"

сов для инкапсуляции данных:

1. Все открытые (public) имена в классе elem наследуются в классе ElemStack.

Эти имена также являются открытыми в ElemStack и известны для любого

пользователя этого стека.

2. Содержимое объекта типа

elem является закрытой (private) информацией

и не известно за пределами определения класса. В нашем примере ToElem

и FromElem действуют как операции приведения типов, которые преобразу"

ют объекты целочисленного типа к типу elem. Такие операции нужны все"

гда, если внутренняя структура класса закрыта.

Ключевые слова private и public используются для определения области види"

мости наследуемых объектов. В языке Java они являются атрибутами объектов

данных. В C++ и Java имеется также ключевое слово protected, означающее, что

имя с этим модификатором является видимым для любых типов, производных от

базового типа, но не известно вне иерархии определения классов.

Реализация. Реализация классов не прибавляет слишком много работы транс"

лятору. Для производного класса к пространству локальных переменных добавля"

ются наследуемые имена базового класса, и только открытые имена делаются ви"

димыми для пользователей этого класса. Истинное распределение памяти для

определенных объектов может быть осуществлено статически с использованием

объявлений данных в определении класса.

Если в определении класса присутствует конструктор, то транслятор должен

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

чает объявление объекта этого класса (например, при входе в блок). Наконец, вы"

зов методов, например x.push(i), обрабатывается транслятором как вызов функ"

ции push(x, i), где x рассматривается как неявный первый аргумент этой функции.

Управление памятью такое же, как в стандартном C; в C++ также может быть ис"

пользована та же самая, что и в C, основанная на стеках организация.

Реализовать управление памятью в языке Java несколько сложнее, так как мас"

сивы в Java являются динамическими. Объявление массива и его размещение в па"

мяти осуществляются при помощи оператора new. Например,

int[] NewArray = new int[10];

создает массив с именем NewArray, а операция new динамически выделяет простран"

ство памяти для десяти целых чисел, которые составят элементы этого массива.

Таким образом, NewArray является просто указателем на это место в памяти. Вирту"

альная машина Java для динамического размещения массивов использует специ"

альную область памяти, называемую кучей.

Для каждого экземпляра класса выделяется собственная область памяти, со"

стоящая из объектов данных, формирующих объекты класса, а также указателей

на все методы, определенные для объектов этого класса. Если некоторый объект

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

316 Глава 7. Наследование

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

детали реализации этого класса в то место памяти, которое отведено для факти"

ческого размещения создаваемого объекта. Этот подход к наследованию называ"

ется основанным на копировании и является наиболее простой и очевидной моде"

лью его реализации.

Альтернативным вариантом реализации является основанный на делегировании

подход. В этом варианте любой объект производного класса будет использовать

область памяти данных базового класса. Наследуемые свойства базового класса не

дублируются в производном объекте. Эта модель подразумевает некую форму сов"

местного использования данных, которая позволяет автоматически изменять про"

изводный объект в соответствии с изменениями базового объекта.

В C++ наследование реализовано с использованием основанного на копирова"

нии подхода, но надо отметить, что альтернативный способ более эффективно ис"

пользует ресурсы памяти (благодаря совместному использованию наследуемых

свойств объектов разными программами) и позволяет автоматически и мгновенно

распространять изменения одного объекта по всей иерархии производных классов.

Множественное наследование

В этом разделе при обсуждении классов в языке C++ предполагалось, что иерар"

хия классов имеет древовидную структуру со множеством производных классов,

наследующих данные и функции, определенные в родительских классах. Это мо"

дель, реализованная в языке Smalltalk, который стал первым объектно"ориентиро"

ванным языком (см. раздел 7.2.5). Но в языке C++ допускается построение новых

классов, производных одновременно от нескольких родительских классов. В объяв"

лении

class A:B,C {…}

класс A является производным как от класса B, так и от класса C. До тех пор пока

множества объектов, определяемых классами B и C, не перекрываются, никаких

проблем с объединением их в одном классе A не возникает. Также не возникает

никаких дополнительных сложностей при реализации классов любым из описан"

ных выше способов.

7.2.2. Методы

Термин объектноориентированное программирование в последние годы был пред"

метом такой шумной рекламы, что быстро утратил свое истинное значение. Для

многих людей этот термин стал синонимом концепции инкапсуляции, которая

обсуждалась в предыдущих разделах и главах. Но объектная ориентация означает

все же нечто большее, чем просто объединение данных и подпрограмм в единый

модуль. Наследование методов при создании новых объектов дает дополнитель"

ные возможности, выходящие за пределы простой инкапсуляции.

Рассмотрим, например, как можно расширить наш пример с классом ElemStack,

приведенный выше. В определение класса, представленное в листинге 7.7, мы

добавили открытую процедуру MyType, которая выводит на печать имя типа: I am

type ElemStack; а также сделали внутреннюю структуру класса ElemStack защищен

317

ной (protected), чтобы она могла наследоваться любым производным от нашего

классом.

В наш класс стека входили только операции push и pop, которые соответственно

добавляли и удаляли элементы стека. Предположим, что нам нужен новый класс

NewStack, который функционирует так же, как класс ElemStack, но включает еще один

метод peek, который возвращает значение верхнего элемента стека, никак не изменяя

при этом сам стек. При помощи определения класса NewStack из листинга 7.7 эта цель,

по"видимому, достигается. Действительно, класс NewStack наследует все свойства класса

ElemStack (все открытые методы и данные), но в него добавлен новый метод peek. Хотя

в определении класса NewStack ничего не сказано об операциях push и pop класса ElemStack

и операциях ToElem и FromElem класса elem, эти операции автоматически становятся при"

менимыми к объектам класса NewStack. Если эти классы поддерживаются как отдель"

ные модули, разрабатываемые разными программистами, изменения в спецификации

(а следовательно, и в реализации) или класса elem, или класса ElemStack будут автома"

тически перенесены и в определение класса NewStack и будут оказывать такое же дей"

ствие на объекты класса NewStack, как и на объекты класса ElemStack.

Листинг 7.7. Наследование методов

class elem {

public:

elem() { v=0;}

void ToElem(int b) { v = b;}

int FromElem() { return v; }

private:

int v; }

class ElemStack: elem {

public:

ElemStack() { size=0;}

void push(elem i)

{ size=size+1; storage[size]=i;}

elem pop()

{ size=size-1; return storage[size+1]}

void MyType() {printf("I am type ElemStack \ n")}

protected:

int size;

elem storage[100]; }

class NewStack: ElemStack {

public:

int peek() {return storage[size].FromElem() }}

Тем не менее некоторая проблема остается нерешенной. Дело в том, что метод

MyStack для объектов типа NewStack по"прежнему печатает I am type ElemStack, по"

скольку этот метод унаследован от класса ElemStack. Эту проблему можно решить

одним из следующих двух способов.

1. Можно просто переопределить метод MyType в классе NewStack следующим

образом:

void MyType() {print("I am type NewStack\n")}

Хотя этот способ и работает, он все же не является оптимальным, поскольку

требует в производном классе полного переопределения каждого метода,

в котором необходимы изменения.

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

318 Глава 7. Наследование

2. Можно использовать виртуальную (virtual) функцию. При определении

метода обычно каждое имя подпрограммы, которая вызывается в определе"

нии, связывается с подпрограммой, на которую оно ссылается, во время оп

ределения метода. Это стандартная методика синтаксического связывания,

присутствующая в языках типа C, Pascal, Ada и FORTRAN и большинстве

компилируемых языков. Но виртуальные подпрограммы динамически свя

зываются во время вызова подпрограммы.

Чтобы понять разницу, определим метод

MyType внутри класса ElemStack следу"

ющим образом:

virtual void TypeName() {printf("ElemStack\n");};

void MyType() {printf("I am type"), TypeName();}

В классе NewStack можно определить TypeName следующим образом:

virtual void TypeName() {printf("NewStack\n");};

Хотя в приведенном примере разница между двумя подходами не очень ярко

выражена, отсроченное, позднее связывание вызова виртуального метода позво"

ляет динамически изменять поведение классов во время выполнения. Такой под"

ход был бы более важен в классах, где методы, подобные MyType, исключительно

длинные и сложные. Вместо того чтобы полностью дублировать этот метод с необ"

ходимыми модификациями в каждом производном классе, требуется переопреде"

лить всего лишь небольшую виртуальную функцию, используемую в методе и от"

ражающую необходимые изменения.

Реализация. Виртуальные методы можно реализовать в некотором смысле ана"

логично центральной таблице окружения записей активаций (раздел 9.4.1). Для

каждого виртуального метода в производном классе резервируется некоторая об"

ласть внутри записи, определяющей этот класс. Процедура"конструктор просто

заполняет эту область, помещая туда ссылку на новую виртуальную процедуру,

если она определена для данного класса. В противном случае в эту область поме"

щается ссылка на виртуальную процедуру из базового класса.

7.2.3. Абстрактные классы

Может возникнуть ситуация, когда нам нужно, чтобы наше определение класса

было всего лишь простым шаблоном для класса и с его помощью не было бы воз"

можно объявлять объекты. Для реализации подобной модели существует два аль"

тернативных способа: абстрактные суперклассы и смешанное (mixin) наследо"

вание.

Абстрактный суперкласс. Рассмотрим класс ElemStack с виртуальной функци"

ей TypeName, определенный выше. Если он определен, то пользователь имеет право

включить в программу оператор

ElemStack X;

и создать экземпляр класса ElemStack. Однако нам может понадобиться, чтобы класс

ElemStack был просто шаблоном суперкласса и чтобы все объекты, использующие

этот класс, принадлежали к производным от него классам. В C++ это можно сде"

лать, объявив TypeName как чисто виртуальную функцию:

virtual void TypeName()=0;

319

Невозможно создать объект класса, содержащего хотя бы одну чисто виртуаль"

ную функцию. Любой производный класс должен переопределить эту функцию

для того, чтобы можно было создавать экземпляры этого класса.

Смешанное наследование. До сих пор предполагалось, что наследование про"

исходит по принципу A ⇒ B, так что класс B является производным и в то же

время модификацией класса A. Имеется и другая форма наследования, называе"

мая смешанной (mixin), при использовании которой мы только определяем разли"

чие между базовым классом и новым производным классом. Вернемся к нашему

примеру и снова рассмотрим базовый класс ElemStack и производный от него класс

NewStack. Вместо того чтобы определять новый класс для класса NewStack, можно

определить дельтакласс, содержащий отличия производного класса от базового.

Хотя на самом деле в языке C++ такая возможность не предусмотрена, мы вос"

пользуемся обозначениями, принятыми в этом языке, для определения дельта"клас"

са StackMode:

deltaclass StackMod

{int peek() {return storage[size].FromElem();}

}

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

class NewStack = class ElemStack + deltaclass StackMod

Смысл этой записи в том, что новый класс наследует все свойства класса

ElemStack в том виде, как они были модифицированы дельта"классом StackMod.

Преимущество смешанного наследования заключается в том, что дельта"клас"

сы могут применяться с любым классом. Так, если бы у нас имелся некоторый

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

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

получить значение элемента в конце очереди:

class newqueue = class ElemQueue + deltaclass StackMod

Этот дельта"класс можно было бы применять в различных ситуациях, избегая

таким образом необходимости сложного переопределения всех объектов класса.

7.2.4. Обзор языка Smalltalk

История. Язык Smalltalk отличается от всех других языков, описанных в этой книге,

в двух отношениях:

1. Он разрабатывался как целая система, а не как просто средство для написа"

ния программ.

2. Объектная ориентация в этом языке изначально была встроенной концеп"

цией в противоположность языкам C++ и Ada, в которых к уже существую"

щим механизмам была просто добавлена концепция наследования.

Использование языка Smalltalk исходно было ограничено отсутствием доступ"

ных реализаций. Но теперь это уже не так. Язык Smalltalk имеет немногочислен"

ных, но преданных приверженцев.

Smalltalk был разработан в начале 70"х гг. Аланом Кеем (Alan Kay) в исследо"

вательском центре Xerox PARC (Palo Alto Research Center). Целью проекта под

названием Dynabook было создание целой среды для персонального компьютера.

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

320 Глава 7. Наследование

Это происходило во время расцвета деятельности Xerox PARC — тогда были раз"

работаны персональные компьютеры Alto и Star, мышь, оконная среда (впо"

следствии весьма эффективно использованная Стивеном Джобсом (Stiven Jobs)

в фирме Apple для разработки компьютеров Macintosh), значки для программ, сети

Ethernet и Smalltalk. В 1972 г. Дан Ингаллс (Dan Ingalls) разработал первую реа"

лизацию языка, известную как Smalltalk"72. Это была первая практическая версия

языка. Затем в Smalltalk были внесены некоторые изменения и общепринятым

стандартом описания языка стал Smalltalk"80. Поскольку официального стандар"

та не существует, название Smalltalk применяется для обозначения набора несколь"

ких достаточно близких и чрезвычайно совместимых языков.

Первоначально для выполнения программ на Smalltalk требовалась целая вы"

числительная среда компьютера специального назначения. По этой причине рас"

пространение этого языка было достаточно ограниченным. Тем не менее в настоя"

щее время существует несколько реализаций этой системы общего назначения, и ее

можно легко устанавливать на машины широкого класса типа рабочих станций

UNIX и PC. В нашей книге мы описываем язык (а также реализацию, использо"

ванную для тестирования представленных в книге программ), соответствующий

версии GNU Smalltalk 1.1.1, разработанной Фондом свободно распространяемого

программного обеспечения (Free Software Foundation), которая легко доступна из

многочисленных источников.

Краткий обзор языка. Уникальность языка Smalltalk определяют следующие

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

книге.

Ê Среда разработки. Smalltalk разрабатывался как целая система: язык, ком"

пьютер и среда программирования. Однако в данной книге мы рассматрива"

ем Smalltalk только как язык программирования и совершенно не касаемся

вопросов, связанных со средой программирования.

Ê Минимальный язык разработки. Небольшой базовый язык определяет Small"

talk. По существу, все, что можно делать в Smalltalk, — это разработать класс

как подкласс других классов и к каждому из разработанных классов присо"

единить методы. Основные операторы Smalltalk определяют присваивание

и последовательное выполнение действий. Истинная мощь языка заключа"

ется в механизме параметрических вызовов, называемых сообщениями. При

помощи сообщений можно определять структуры управления, подобные

нашим обычным конструкциям

if и while.

Smalltalk поставляется с предопределенным набором определений клас"

сов, написанных на языке Smalltalk. Когда Smalltalk устанавливается на

компьютер, то создается образ пустого окружения путем включения всех

этих определений. При вызове интерпретатора Smalltalk вы получаете свою

собственную копию этого образа. Внутри этого образа вы строите новые

классы и модифицируете существующие классы добавлением или изме"

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

Smalltalk с альтернативным набором предопределенных определений клас"

сов, так что не совсем понятно, что следует понимать под языком Smalltalk.

В данной книге мы называем языком Smalltalk набор предопределенных

классов.

321

Ê Выполнение программы Smalltalk. Модель выполнения для Smalltalk основа"

на на коммуникационной модели (communication model). Данные в Smalltalk

состоят из объектов, а методы рассматриваются как сообщения, посылае"

мые объектам. Так, 1 + 2 означает, что сообщение «+» с параметром 2 посла"

но целочисленному объекту

1. Метод «+» в данном

случае возвращает зна"

чение 3. На первый взгляд это может показаться странным, но становится

вполне естественным после небольшой практики.

Smalltalk использует динамическую модель последовательности выпол"

нения действий. Каждый метод выполняется с одновременным созданием

записи активации, называемой контекстом. Так как блоки, которые содер"

жат локальные переменные, могут быть присвоены переменной, то стеко"

вый механизм организации памяти, при котором читается последний запи"

санный объект, становится здесь некорректным. Как для хранения объектов

данных, так и для хранения записей активации Smalltalk должен использо"

вать динамическую организацию памяти в виде кучи. Как правило, исполь"

зуется динамическая сборка мусора, хотя семантика необходимой сборки

мусора в языке не специфицирована.

7.2.5. Объекты и сообщения

Smalltalk представляет альтернативный подход к разработке объектов и методов,

значительно отличающийся по своей идеологии от моделей наследования, пред"

ставленных ранее в этой главе для языков Ada и С++. Идея Smalltalk принадлежит

Алану Кею из Xerox Palo Alto Research Center, он предложил ее в начале 70"х гг.,

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

работчиков. Smalltalk был разработан как целая вычислительная среда для персо"

нального компьютера. Поэтому он включал в себя не только язык для представле"

ния алгоритмов, но и среду вычисления, состоящую из разделенного на окна

(windows) экрана монитора и мыши рабочей станции Xerox Alto. Теперь подоб"

ные возможности являются общепринятыми, но в то время их появление рассмат"

ривалось как революционный шаг вперед.

Программа на Smalltalk состоит из набора определений классов, состоящих, в свою

очередь, из объектов данных и методов. Все данные инкапсулированы, так как толь"

ко методы, определенные для класса, имеют доступ к данным, принадлежащим

этому классу. Сокрытие информации и инкапсуляция являются неотъемлемыми

встроенными свойствами языка в отличие от C++, в котором эти свойства были

добавлены поверх уже существующей структуры типов языка.

Программа на Smalltalk обычно включает в себя три основные составляющие.

1. Определения классов. Они представлены выполняемыми операторами, оп"

ределяющими внутреннюю структуру и методы, которые могут быть исполь"

зованы для создания и манипуляции объектами класса. Также могут быть

определены данные, используемые совместно всеми объектами определен"

ного класса.

2. Создание объектов. Для каждого определения класса создаются свои объек"

ты посредством вызова методов создания в определении этого класса. Ме"

тоды можно определять для отдельных экземпляров класса.

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

322 Глава 7. Наследование

3. Передача сообщений. Для выполнения действий объектам передаются мето"

ды в форме сообщений. Вместо того чтобы связывать с функцией набор

параметров, как это делается в большинстве других языков, в Smalltalk функ"

ция (то есть метод) связывается с объектом данных. Эта связь метода с объ"

ектом называется сообщением.

В Smalltalk существуют три типа сообщений:

1. Унарное сообщение — это метод, не имеющий параметров. Например, для

создания объектов в большинстве классов используется встроенный метод

new:

x _ Set new

В данном случае переменной x присваивается вновь создаваемый объект

класса Set. Теперь x является экземпляром объекта класса Set.

2. Бинарное сообщение, как правило, используется для арифметических опе"

раций. Выражение 3 + 6 соответствует бинарному методу «+», посланному

объекту 3 с параметром 6. Метод «+» возвращает объект 9 как результат дан"

ного сообщения.

3. Ключевые сообщения ведут себя примерно так же, как перегруженные функ"

ции в языках типа Ada и С++. Например, для присвоения значения третье"

му элементу массива x следует сначала создать массив с нужным количе"

ством элементов, а затем выполнить операцию присваивания:

x _ Array new:10

x at:3 put:42

Сначала метод new: с параметром 10 посылается классу Array для создания

массива из десяти элементов, который присваивается переменной x. Вызы"

вается ключевой метод at: и put: для присваивания третьему компоненту

массива x значения 42. Название at:put: метода этого оператора присваива"

ния образуется путем конкатенации ключевых слов (at: и put:). Другой ме"

тод, at:, посланный экземпляру массива, извлекает значение соответствую"

щего элемента массива.

Использование символа «_» для обозначения операции присваивания объяс"

няется некоторыми фактами из истории развития компьютерной техники. Ис"

ходно операция присваивания в Smalltalk обозначалась символом ←, который

в 60"е и 70"е гг. был представлен на клавиатурах той же клавишей, что и символ

«_», поэтому внутреннее определение этих символов было одинаковым. Со вре"

менем символ ← исчез с клавиатуры, но в Smalltalk используется символ, ко"

торый соответствует той же клавише. Аналогично операция, указывающая воз"

вращаемое каким"либо методом значение, исходно обозначалась символом ↑,

который размещался на той же клавише, что и символ «^». Со временем этот сим"

вол также исчез с клавиатуры.

Последовательности операторов в Smalltalk могут быть выполнены как блоки,

например:

[ :ëîêàëüíàÿ_ïåðåìåííàÿ | îïåðàòîð

… îïåðàòîð

]

где ëîêàëüíàÿ_ïåðåìåííàÿ — это необязательная локальная переменная, объявлен"

ная в блоке. (Первый символ : в блоке необходим для устранения синтаксической

неоднозначности в определении блоков.) Выполнение блока операторов происхо"

323

дит посредством передачи метода

value этому блоку, а результатом выполнения

является последнее выражение блока. Так

| x |

x _ ['Ýòî ñòðîêà']. "Ïåðåìåííîé x ïðèñâîåí äàííûé áëîê."

x value print ! "Âû÷èñëÿåòñÿ áëîê ïåðåìåííîé x."

означает следующее:

1) объявляется локальная переменная x;

2) переменной x присваивается блок;

3) метод x value возвращает строку Ýòî ñòðîêà, которая печатается методом print.

В Smalltalk комментарии обозначаются двойными кавычками. Символ ! в Small"

talk обозначает команду для выполнения предыдущей последовательности опера"

торов.

Использование передачи ключевого параметра позволяет создавать многие

широко используемые структуры управления. Предопределенное окружение Small"

talk включает встроенный метод для работы с булевыми данными ifTrue:ifFalse:.

Каждое из этих ключевых слов получает в качестве параметра некоторый блок

данных. Например, true ifTrue:ifFalse: вычислит блок ifTrue:, тогда как false

ifTrue:ifFalse:

вычислит блок ifFalse:. Записывая эти конструкции с использова"

нием общепринятых отступов, подобных тем, что применяются в языке Pascal, мы

получим следующий синтаксис:

x > 2

ifTrue: ['x áîëüøå 2' printNl]

ifFalse:['x ìåíüøå èëè ðàâåí 2' printNl]

В данном случае метод > с параметром 2 передается объекту x. Метод > возвра"

щает объект true или false в зависимости от значения x. Этому булевому объекту

затем передается ключевой метод ifTrue:ifFalse: с двумя блоками в качестве па"

раметров. В зависимости от того, какой был возвращен булев объект, выполняется

блок ifTrue: или ifFalse:. (Метод printNl аналогичен методу print, за исключени"

ем того, что после напечатанного объекта он печатает также символ новой строки.)

Алгоритм вычисления очень похож на вычисление оператора if-then-else, но фак"

тическое выполнение радикально отличается. Используя этот подход, можно ана"

логичным образом разработать циклические конструкции.

Smalltalk — единственный из описанных в нашей книге языков, полностью ос"

нованный на концепциях инкапсуляции и абстракции. Наследование в Smalltalk

является базовой характеристикой процесса вызова методов.

Неупорядоченность в определении методов приводит к другой проблеме в опре"

делении методов — неоднозначности. Например, рассмотрим следующие методы:

!Datastore class methodsFor: 'Misc'!

asgn: aValue to: bValue

aValue printNl !

to: aValue asgn: bValue

aValue printNl !!

На первый взгляд это выглядит как неоднозначное определение метода asgn:to:.

Тем не менее to:asgn: — это совсем другой метод:

st> Datastore asgn: 8 to: 9 !

Execution begins...

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

324 Глава 7. Наследование

st> Datastore to: 9 asgn: 8 !

Execution begins...

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

имен.

У языка Smalltalk, как было сказано, имеется некоторый (хотя и небольшой)

круг сторонников. Этот язык достаточно интересен, но лишь немногие коммерче"

ские системы были написаны на этом языке. Недостаточное количество доступ"

ных трансляторов Smalltalk до сих пор затрудняло его распространение. Возмож"

но, теперь, когда трансляторы стали легко доступны, ситуация изменится.

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

Данные в Smalltalk организованы на основе иерархии классов. Если какой"либо

метод, который передается объекту, не определен внутри этого класса, то он пере"

дается родительскому классу и т. д. Класс

Object является родительским супер"

классом для всех классов. Наследование методов соответственно является основ"

ным свойством языка. Однако допускается только простое наследование с одним

родительским классом для каждого дочернего класса, хотя методы могут переда"

ваться через несколько уровней родительских классов.

Для ключевых методов параметры явным образом указаны в объявлении мето"

да, как, например, в следующем случае:

ifTrue: trueBlock ifFalse: falseBlock

"Ïåðåìåííûå trueBlock è falseBlock ÿâëÿþòñÿ ïàðàìåòðàìè

â òåëå ìåòîäà."

Но каким образом можно получить доступ к объекту, которому передан метод?

Например, если x>2, каким образом метод > получает доступ к объекту x и получа"

ет его значение? Для этого существует объект self. Он ведет себя примерно так же,

как параметр this в C++.

Необходимость объекта self и его использование в иерархии объектов можно

продемонстрировать на следующем простом примере. Предположим, нам требу"

ются два класса: ClassA и ClassB, являющийся подклассом ClassA. Эти классы мож"

но определить следующим образом:

Object subclass: #ClassA

instanceVariableNames: ' '

classVariableNames: ' '

poolDictionaries: ' '

category: nil !

ClassA subclass: #ClassB

instanceVariableNames: ' '

classVariableNames: ' '

poolDictionaries: ' '

category: nil !

ClassA определен как подкласс класса Object (просто для того, чтобы поместить

его в какое"то место в иерархии Smalltalk), а ClassB является подклассом ClassA.

instanceVariableNames определяет набор локальных имен, используемых в каждом

отдельном экземпляре объекта этого класса, в то время как classVariableNames —

это глобальные данные, которые используются во всех экземплярах объектов это"