Объекты и сообщения
Перевод от Fedir Koshovyy, 2003
Smalltalk известен как Объектно Ориентированный Язык Программирования. Когда Вы запускаете образ своей Dolphin системы, Вы переносите в память своего компьютера море взаимосвязанных и сообщающихся объектов. Эта глава вводит понятия, что такое на самом деле объекты и как Вы можете использовать сообщения, чтобы общаться с ними.
Пожалуйста, откройте окно новой рабочей области, используя File/New, чтобы попробовать примеры, представленные ниже.
Что такое Объект?
На самом простом уровне, объект - это всего лишь область памяти Вашего компьютера, которая содержит состояние объекта, некоторые данные в байтовом представлении. Например, объект, представляющий текстовую строку, 'hello', может содержать (кроме всего прочего) байты:
104 101 108 108 111
Здесь каждый байт, конечно, представляет один символ в этой строке. Тем не менее, каждый объект также содержит дополнительную информацию, которая позволяет ему "знать", какого он вида. Каким образом это знание зашифровано как часть объекта на данном этапе не имеет значения, но это очень важно, т.к. позволяет этому объекту определять его поведение. Например, если у нас есть два объекта, которые являются числами, вполне резонно, что мы должны иметь возможность вычесть одно из другого. Если, тем не менее, у нас есть две текстовые строки, мы не ожидаем возможности, совершить подобную операцию вычитания. Фактически то, что объекты-числа "знают" что они числа, позволяет им определить, что вычитание является допустимой операцией и, таким образом, как такое вычитание должно быть совершено.
В Dolphin, есть объекты, которые представляют (кроме всего прочего):
- Текстовые строки
- Числа
- Словари
- Текстовые редакторы
- Окна
- Программы
В Smalltalk:
- Все является объектом.
- Все объекты знают, какого вида или класса, они есть.
Класс - очень важное слово, выражаясь языком Smalltalk. Класс объекта позволяет ему определять как он должен себя вести.
На заметку: тот факт, что все в Smalltalk является объектом, в высшей степени важен. Он делает Smalltalk очень чистым объектно-ориентированным языком программирования, значительно более чистым, чем другие языки, такие как C++ или Java. Эта чистота придает единообразие системе, что делает этот язык простым в изучении и, тем не менее, очень мощным.
Когда Вы программируете в Smalltalk, некоторые объекты могут быть представлены непосредственно в языке. Они называются литералы (literals). Посмотрите на следующие примеры литеральных объектов:
'Hello world' - текстовая строка $H - символ H 517 - целое число 789.45 - число с плавающей точкой #(1 2 3) - массив из трех целых чисел #show - специальный объект, который называется Символ (Symbol)
Объекты общаются посредством Сообщений
В Smalltalk, объекты посылают сообщения один другому, в результате чего что-то происходит. То, каким образом объект реагирует на определенное сообщение, описывается классом объекта, к которому он принадлежит, и очень важно понимать, что не все объекты успешно реагируют на все сообщения. Набор сообщений, которые должен понимать объект, и его реакции на эти сообщения, определяют поведение объекта в Smalltalk системе.
Все объекты знают, какой набор сообщений они могут понимать. Этот набор управляется классом объекта.
Далее представлены типичные сообщения, которые могут быть посланы:
+ - new show exit includes: asSortedCollection
Вы можете использовать язык Smalltalk для создания объектов и посылки им сообщений. Создайте новое окно рабочей области (File/New) и попробуйте следующие примеры. Вы можете отобразить результат вычисления каждой строки отдельно.
На заметку: Запомните, вам не обязательно выделять всю строку для того, чтобы сделать это, всего лишь поставьте курсор где-нибудь на строке и нажмите Ctrl+D (Workspace/Display it) что бы вычислить и отобразить результат.
3+4. 'Hello world' reverse. 5 factorial.
Простые сообщения.
Простое Сообщение единственное, которое не требует дополнительной информации или параметров кроме себя самого. Такие сообщения должны начинаться с маленькой буквы и дальше могут содержать любые буквы или числа или знак подчеркивания (_). Попробуйте отобразить результат следующего примера:
5 squared.
Здесь сообщение squared послано объекту, представляющего собой целое число 5. Все сообщения возвращают ответ какого-либо вида и, в данном случае, он будет 25.
Одно из замечательных свойств Smalltalk - его способность эффективно обрабатывать очень большие числа неограниченной точности. Попробуйте это:
200 factorial.
Еще несколько сообщений:
'mary had a little lamb' asUppercase.
Сообщение asUppercase, будучи посланным объекту-строке, создает новую строку с содержанием оригинальной, но с буквами, конвертированными в верхний регистр. Эта новая строка затем возвращается как результат сообщения.
#(3 4 5 6 7) size.
Сообщение size, будучи посланным данному объекту-массиву, содержащему пять целых числа, вернет число элементов в массиве, в данном случае, 5.
Объект, которому посылается сообщение, называется Получатель (receiver). Сообщение само себя иногда называет селектор (потому, что оно выбирает, какая операция должна будет выполниться) и результат обычно называется ответ (answer).
Сообщения, не понятные системе.
Мы упоминали раньше, что объект ответит только на определенный набор сообщений, в зависимости от того, к какому классу он относится. На пример, объект, являющийся числом, будет с успехом обрабатывать арифметические операции. Мы, тем не менее, действительно не ожидаем такого же поведения от объекта - текстовой строки. Давайте нарочно пошлем сомнительное сообщение строке:'Hi Andy' squared.
Обратите внимание, что это приводит к появлению окна отказа. Dolphin использует это окно для отображения возникших ошибок. Заголовок окна показывает основную проблему, в данном случае, Строка не понимает #squared. На этом этапе, Вы можете войти в системный отладчик (нажав кнопку Debug) для дальнейшего изучения проблемы. Понимание отладчика нам не нужно на данном этапе, поэтому, когда это случится, используйте клавишу Terminate.
Посылка Сообщений поверх Сообщений.
Когда Вы посылаете сообщение получателю, Вы всегда получаете в ответ другой объект. Вполне очевидно, что Вам бы хотелось иметь возможность послать следующее сообщение этому ответу. Попробуйте:20 factorial displayString.Здесь сообщение
displayString, послано результату операции 20 factorial. Посмотрите внимательно, и Вы увидите, что то, что отобразилось, заключено в одинарные кавычки, это показывает, что целочисленный результат был конвертирован в строковое представление. Возможно, мы хотим дополнительно знать, сколько знаков содержится в строке для результата операции 20 factorial:
20 factorial displayString size.Таки образом, Вы можете видеть, что Вы можете использовать последовательность сообщений для создания более сложных выражений.
Бинарные Сообщения.
Иногда сообщению необходима дополнительная информация для совершения работы. Определенные сообщения, которые называются Бинарными Сообщениями, требуют два объекта; получатель и один параметр. Попробуйте:
3 + 4. 6 * 5. 5 squared + 6. 4 ** 3.
Последнее сообщение ** представляет собой возведение в степень, это выражение возводит 4 в 3 степень. Здесь, целочисленный объект 4 является получателем, а 3 является единственным параметром, который необходим сообщению **.
Как видно, бинарные сообщения часто используются для осуществления арифметических операций в Smalltalk. Сообщения содержат один или более специальный знак, которые не являются ни буквой, ни цифрой. Они могут использоваться и для других операций:
'skin' , 'diver'.
Сообщение , используется для конкатенации (сцепления). В данном случае он используется для присоединения строки 'diver' к получающему объекту, строке 'skin'. Ответом на операцию буден новая строка, которая состоит из сцепления двух исходных строк. По правде говоря, это сообщение может использоваться для сцепления многих подобных наборов объектов:
#(1 2 3) , #(4 5 6).
Иногда сообщения используются просто для "создания" нового объекта. Мы узнаем больше об этих конструкторах или сообщениях класса позже, но здесь есть интересный пример использования бинарного сообщения @:
(50 @ 150) class.
Сообщение @, посланное целому числу, используется для создания объекта - двумерной точки. Сообщение класса просто просит поучившийся объект ответить, к какому классу он принадлежит (чуть позже мы узнаем о классах больше). Важно в этом примере то, что последовательность 50@150, в языке Smalltalk, представляет двумерную точку, но, очень важно понять, что символ @ не является частью языка сам по себе. Напротив, это просто сообщение, которое совершает определенную операцию (в данном случае, создание объекта-точки) как и любое другое бинарное сообщение. Ради интереса, попробуйте некоторые другие операции над точками.
(50 @ 150) + (25 @ 35). (640 @ 480) * 3.
Ключевые Сообщения
Выше мы видели, что бинарные сообщения используют только один параметр. Бинарными сообщениями являются специальные символы, такие как: + * - / и т.д. Существует также возможность передать параметры сообщением, по стилю, более приближенному к человеческому языку.
#(100 600 800 1000) at: 2. #(100 200 #(1 2 3) 800 1000) at: 3.
Как показано выше, сообщение at: может быть использовано для доступа к объекту по определенному адресу в массиве, или другой индексируемой коллекции. Во втором примере показано, что у вас могут быть более сложные массивы, которые даже включают другие массивы в качестве своих элементов. В этом есть смысл, так как массив может свободно хранить любые типы объектов. Вот Вам еще немного примеров ключевых сообщений, которые принимают один параметр:
#(100 200 #(1 2 3) 900 1000) includes: 30 squared. 'Hello World' occurrencesOf: $o. 1 to: 10.
Последнее еще один пример сообщения-конструктора подобно @. В этом случае to: будучи посланным целому числу, вернет особый вид коллекции, известной как Интервал (Interval). Интервалы могут применяться там же, где и любые другие коллекции, и представляют диапазон целых чисел. В данном случае от одного до десяти. Что бы это увидеть лучше, попросите его сконвертировать себя в массив:
(1 to: 10) asArray.
До сих пор мы видели, как один параметр может передаваться сообщениям, которые заканчиваются : (двоеточием). Можно создать сообщения, которые принимаю любое количество параметров:
#(1 2 3) at: 2 put: 'Hello'; yourself
Мы вернемся к использованию точки с запятой и сообщения yourself в разделе о Каскадах Сообщений ниже. А сейчас сконцентрируемся на at: и put:. Это не два отдельно посланных сообщения, а одно, принимающее два параметра. Мы ссылаемся на селектор для этого ключевого сообщения как at:put:. Как видите, сообщение at:put: может использоваться помещения объектов в индексируемые коллекции, такие как массивы (arrays) или строки (strings). Попробуйте:
'Thomas,Henry,Edward' copyFrom: 8 to: 12. 'Thomas,Henry,Edward' midString: 5 from: 8. 'Hello World' at: 6 put: $-; yourself. 'The brown quick fox' replaceFrom: 5 to: 15 with: 'a quick brown' startingAt: 3
Можете ли Вы сказать какой селектор сообщения в последнем примере? Да, это одно сообщение, принимающее четыре параметра, с селектором,
replaceFrom:to:with:startingAt:.
На заметку: Надеюсь, Вы заметили, что тот способ, который использует Smalltalk, вставлять параметры в тело селектора сообщения, может привести к намного более читабельному программному коду, чем во многих других языках программирования. Если Вы раньше использовали такие языки, как C++ или Java, Вам может сначала показаться это странным, но держу пари, что очень скоро Вам это понравится!
Комментарии
Комментарии могут быть вставлены в Ваш Smalltalk код, чтобы предоставить дополнительную информацию для помощи тому, кто будет читать программу. Комментарий - это просто текст, заключенный в двойные кавычки.
"This is a comment"
Обычно, Smalltalk требует меньше комментариев, чем другие языки, потому, что текст программы очень читабельный. Вам следует добавлять комментарии только тогда, когда они значительно улучшают понимание кода.
Комментарии могут возникать где угодно, но они не должны разбивать основные элементы языка, такие как селекторы сообщений или числа. Например:
365 "Days per year" * 24 "Hours per day"
допустимо, тогда как:
36"Days per year"5 * 2"Hours per day"4
нет. Последнее сообщение вызовет ошибку компилятора Dolphin Smalltalk.
На заметку: пользователи других языков привыкли использовать двойные кавычки для обозначения текстовых строк. Очень важно, что бы Вы обратили особое внимание на это отличие Smalltalk: двойные кавычки отделяют комментарии, а одиночные кавычки отделяют текстовые строки.
Арифметика (Arithmetic)
Посмотрите на сообщения для произведения простых арифметических операций над числами.
300 + 400 "Сложение" 3.141926 - 3 "Вычитание" 365.25 * 24 "Умножение" 8766 // 24 "Деление целых чисел с отбрасыванием дробной части" 8766 / 24 "Стандартное деление"Интересно отметить, что в Smalltalk арифметика такова, что нет необходимости подбирать типы чисел или предвидеть тип результата. Например, вполне нормально вычесть целое число из числа с плавающей точкой и получить соответствующий результат с плавающей точкой. Вы должно быть хорошо знакомы с разницей между сообщениями целочисленного и стандартного деления. Сообщение (
//) будет всегда урезать результат до наименьшего целого. Последнее (/) будет обеспечивать точность результата, возвращая дробный результат или с плавающей точкой, в зависимости от того, который лучше подходит.
Существующая в Smalltalk возможность переключения между различными представлениями чисел для обеспечения точности где угодно - ценная концепция. Где угодно он старается избегать использования объекта с плавающей точкой, удерживая значение, т.к. многим вычислениям с плавающей точкой свойственна неточность в нижних десятичных разрядах. Используя объекты (класса Дробь (Fraction)) для представления дробных величин можно сохранить наибольшую точность там, где она в противном случае была бы потеряна. Например:
6 / 18
Если бы этот иррациональный результат был бы приведен к типу с плавающей точкой (0.333333), любые последующие вычисления с этим числом могут привести к потере точности. Напротив, дробная величина (1/3) остается точным сам собой. Единственная проблема может быть в том, что Вы не пожелаете отображать дробь как конечный результат своего вычисления, т.к. многие люди находят представление в виде десятичного числа более приемлемым. Ответ прост, принудительно конвертируйте в соответствующее представление, когда вам необходимо отобразить результат. Вы можете попробовать это:
(6 / 18) asFloat
Порядок Выполнения Сообщений
Порядок, в котором Smalltalk производит вычисление более сложных арифметических выражений, отличается от того, который Вы могли бы ожидать, особенно если Вы использовали другие языки программирования. Например, попробуйте отобразить результат выражения:
3 + 4 * 5
Вы, возможно, ожидали увидеть результат 23, но Smalltalk выдает 35. Это потому, что мы обычно думаем, что операции умножения и деления имеют более высокий приоритет, чем сложение и вычитание. Мы ожидаем, что умножение должно быть выполнено перед сложением. Тем не менее, в этом случае, это не так. В Smalltalk, все бинарные сообщения имеют одинаковый приоритет и будут исполнены по порядку "первый пришел, первым обслуживается". Это незначительное неудобство, но есть средство - всегда использовать соответствующие скобки там, где может возникнуть путаница. Посмотрите, как это дает ожидаемый результат:
3 + (4 * 5)
Тем не менее, Smalltalk вводит несколько правил выполнения операций. Они очень простые и, в большинстве случаев (за исключением арифметических приоритетов), они делают код таким читабельным. Порядок выполнения сообщений в любых выражениях таков:
Простые сообщения (наивысший приоритет)
Бинарные сообщения
Ключевые сообщения (низший приоритет)
Попробуйте выполнить следующие примеры и попробуйте предугадать результат:
3 squared + 4 squared #(130 140 150 160) at: 4 - 2 5 factorial gcd: 'a string' size "gcd: computes Greatest Common Divisor" 3 squared + 4 squared sqrt (3 squared + 4 squared) sqrt
Переменные и Присваивание
До сих пор, мы выполняли отдельные Smalltalk выражения и отображали результат. Smalltalk программа, работающая с реальными значениями, должна содержать множество таких выражений и, чтобы быть удобной, должна быть готова хранить где-нибудь результаты. Все компьютерные языки программирования используют переменные, в которые помещают промежуточные значения, на которые можно в последствии ссылаться.
В Smalltalk, переменная - это именованный слот или место, в которое может быть помещен любой объект. Имя переменной должно начинаться с буквы, но в последствии, может содержать любые буквы, числа или символы подчеркивания. Ниже представлены допустимые имена переменных:
name address dayOfWeek outerCount2 day_of_week
Несмотря на то, что последняя переменная, day_of_week, имеет допустимое имя, в Smalltalk существует договоренность составлять такие имена без символов подчеркивания, а начиная последующие слова с большой буквы. Таким образом, dayOfWeek - более предпочтительное имя.
Вы можете поместить объект в переменную, используя присваивание. Попробуйте следующее разложение теоремы Пифагора. Если Вы хотите, Вы можете только выполнить (используя Ctrl+E) первые несколько строк, а отобразить (используя Ctrl+D) только последнюю строку.
a := 6. b := 7. hypotenuseSquared := a squared + b squared. "By Pythagoras" hypotenuse := hypotenuseSquared sqrt.
Возможно, Вы здесь отметили еще что-то новое в дополнении к использованию оператора присваивания (:=).Язык Smalltalk использует точку (.), чтобы разделить отдельные выражения. Теперь Вы можете вычислять несколько выражений за один раз. Попробуйте снова выполнить предыдущий пример, но теперь, отметьте весь текст перед тем, как нажать Ctrl+D.
Единственное, что отличает переменные Smalltalk и переменные, используемые в других языках это отсутствие типов. Переменная Smalltalk - это всего лишь слот, приспособленный к хранению любого объекта; вы не обязаны декларировать переменную, чтобы она была только определенного типа. Это делает переменные Smalltalk более простыми в использование и, в конечном счете, более гибкими.
На заметку: бестиповую природу переменных Smalltalk часто приводят как показатель того, что Smalltalk не является "защищенным" языком. Языки со строгой типизацией переменных, которые настаивают на том, что переменная должна быть объявлена такой, которая может содержать только определенный тип значения, выглядят более защищенными, поскольку компилятор может выполнить больше проверок и, тем самым, уменьшить количество проблем, которые возникнут во время исполнения.
Тем не менее, Smalltalk ЯВЛЯЕТСЯ в высшей степени защищающим типы. Даже если неправильный класс объекта будет помещен в слот переменной, проблема не пройдет незамеченной во время выполнения теста. Объект не ответит на тот набор сообщений, который он не ожидает и вызовет диалог ошибки, неподходящее сообщение не будет понято.
Dolphin Smalltalk поддерживает три отдельных типа переменных, Рабочей области (Workspace), Временные (Temporary), Экземпляра (Instance) и Глобальные (Global).
Переменные рабочей области (Workspace Variables)
Переменные рабочей области принадлежат той рабочей области, в которой они были созданы. Они создаются автоматически, когда присваивание применяется к переменной, которая начинается с маленькой буквы и которая еще не объявлена. Все переменные в предыдущем примере являются переменными рабочей области. Слоты переменной и объекты, которые они содержат, существуют до тех пор, пока рабочая область не будет закрыта. Например, попробуйте отобразить:
hypotenuse.
Эта переменная, созданная в предыдущем примере, все еще существует и содержит вычисленный результат. Она будет существовать, пока окно рабочей области будет открыто и будет доступна для любых других выражений, которые будут выполняться в этой рабочей области. Однако она не будет видна из любой другой открытой рабочей области.
Временные Преременные (Temporary Variables)
Также возможно использовать временные переменные, которые существуют только во время выполнения ряда выражений. Эти переменные должны объявляться и их имена должны быть заключены между символами вертикальной черты перед первым из серии выражений, в которых они используются. Имена временных переменных должны начинаться с маленькой буквы.
Вы должны выбрать весь следующий код, чтобы выполнить и отобразить результат как один блок,
| c d theta | c := 8. d := 4. theta := (d / c) arcSin * 360 / (Float pi*2).
Как только выполнение будет закончено, все временные переменные автоматически уничтожаются.
Обычно, временные переменные не используются, когда выполняют выражения, используя рабочую область; гораздо чаще Вам лучше использовать вместо этого переменные рабочей области. Временные переменные чаще используются в методах, речь о которых пойдет в следующей главе, Классы и Методы.
Переменные Экземпляра
Объекты должны где-то хранить информацию о своем состоянии, и такое место - переменные экземпляра. Объект может иметь один или больше слотов переменных, где хранится его внутренняя информация. Переменные экземпляра являются частными по отношению к объекту и не доступны из внешнего мира. Это позволяет объекту держать свое внутреннее представление скрытым, таким образом его пользователям приходится доверять ему. Поскольку пользователю непозволительно управлять другими переменными экземпляра объекта, таким образом, сообщения становятся единственным способом связи с ним. Такая инкапсуляция является очень важным принципом Объектно Ориентированного Программирования.
Как создавать и использовать переменные экземпляра Вы увидите в главе Классы и Методы.
Глобальные Переменные (Global Variables)
Глобальные переменные похожи на переменные рабочей области, за исключением того, что ни принадлежат системе, а не определенной рабочей области. Однажды создав глобальную переменную, она остается существовать, удерживая любое содержимое, которое Вы можете присвоить ей, до тех пор, пока Вы явно не удалите ее. Имя глобальной переменной должно начинаться с большой буквы.
Если выполните этот код, появится подсказка, действительно ли Вы хотите создать глобальную переменную, MyName. Нажмите "Yes" в подтверждение этого.
MyName := 'Arthur J. Rank'. MyName , ' was here'.
Очень важно очищать все глобальные переменные, созданные Вами, после того, как Вы закончили их использование. Чтобы сделать это для MyName, выполните следующий код (заметьте, что знак # непосредственно предшествует имени):
Smalltalk removeKey: #MyName.
Вы поймете, что Вам не часто придется явно создавать глобальные переменные. Тем не менее, есть один тип глобальных переменных, которые Вы будете создавать регулярно. Глобальные переменные используются для хранения объектов-классов, которые формируют фундамент Вашего Smalltalk программирования. Об этом также будет идти речь в главе Классы и Методы.
Smalltalk поддерживает целый ряд глобальных переменных, большинство из которых классы. Еще одна, которая часто оказывается полезна - Transcript. Она может использоваться для обращения к окну System Transcript для посылки полезных текстовых сообщений ему:
10 timesRepeat: [Transcript show: 'A useful message?'; cr].
Проверьте окно Transcript, и убедитесь, что сообщение вывелось на него 10 раз.
Каскадные Сообщения (Cascading Messages)
Давайте попробуем создать новое окно и поуправлять им. Выполните следующие строки по отдельности, чтобы увидеть нарастающий эффект:window := ShellView new show.
В этом месте Вам необходимо вернуться к рабочей области, так как новое окно будет выведено на передний план. Давайте продолжим:
window position: 80@80. window extent: 320@90. window backcolor: Color red. window caption: 'My Red Test Window'.
Мы посылаем последовательно сообщения одному и тому же получателю. Очень удобно, что Smalltalk предлагает более короткий способ делать это, через каскадирование этих сообщений общему получателю. Следующий код выполняет подобную последовательность, но должен быть выполнен за один шаг, поскольку все строки являются частью единого выражения.
window := ShellView new show. window position: 80@80; extent: 320@90; backcolor: Color blue; caption: 'My Blue Test Window'.
Здесь, каждое из каскадных сообщений разделено точкой с запятой. Каждое послано непосредственно объекту, который хранится в переменной window. Отступы в строках сделаны в соответствии со стилем, принятым в Smalltalk, для того, чтобы сделать код более читабельным.
Не забудьте закрыть свои красное и синее окна, когда закончите работу с ними.
Каков же будет результат серии каскадных сообщений? Конечно, это будет ответ от последнего сообщения в последовательности. Попробуйте этот фрагмент:
rect := Rectangle origin: 0@0 extent: 10@10. rect area
Мы создали объект Прямоугольник (Rectangle) площадью в 100 квадратов. Теперь давайте изменим этот прямоугольник так, чтобы он был размером 8 на 8 квадратов, и пересчитаем площадь. Как только Вы выполните этот фрагмент как одно выражение:
rect top: 1; left: 1; bottom: 9; right: 9; area
Отобразившийся результат - это ответ последнего сообщения в последовательности, area.
Yourself
Иногда полезно, чтобы ответом серии каскадных сообщений было не результат последнего сообщения, а сам получатель сообщений. Для этого Вы можете использовать сообщение yourself. Сравните два следующих примера:
sequence := OrderedCollection new add: 1; add: 4; add: 9; add: 16.
В этом примере, отображенным результатом будет 16, который является ответом последнего сообщения add: (так принято, чтобы каждое сообщение add: всегда возвращало в качестве ответа свой параметр). Вероятно это не то, что нам нужно, поскольку фактическая последовательность сообщений уже потеряна. Более вероятно, то, что мы ожидаем, будет:
sequence := OrderedCollection new add: 1; add: 4; add: 9; add: 16; yourself.
Сообщение yourself всегда возвращает в качестве ответа получателя, пославшего его. В данном случае, получателем является объект OrderedCollection и, поскольку, yourself является последним посланным сообщением в каскадной последовательности, он и будет в результате возвращен.
Селекторы Сообщений (Message Selectors) являются Символами (Symbols)
Раньше мы упоминали, что в Smalltalk все является объектом. Это также относится к селекторам сообщений; они также объекты. Фактически, они являются примерами определенного класса объектов, называемых Символы (Symbols). Символы подобны текстовым строкам, за исключением того, что они начинаются со знака# вместо того, чтобы быть заключенным в одинарные кавычки. Следующие примеры являться литеральными символами.
#show #at:put: #add:
Символы не могут содержать пробелов.
Очень важно то, что символы уникальны. Этот вопрос будет более подробно объяснен в главе "Равенство и Идентичность" (Equality and Identity), но важно запомнить, что селекторы сообщений, фактически, Символы. Исходя из этого, они обычно записываются, начиная со знака #. Это соглашение будет использоваться в дальнейшем в этом руководстве.
Что Вы изучили?
Этот раздел был таким длинным просто потому, что фактически Smalltalk это работа с Объектами и Сообщениями. По этой причине, Вы теперь можете утешать себя тем, что Ваши знания охватывают около 80% языка Smalltalk. К настоящему моменту Вы изучили:
Объекты
Простые сообщения
Бинарные сообщения, принимающие единственный параметр
Ключевые сообщения, принимающие один или более параметров
Последовательности сообщений
Порядок или приоритет сообщений
Каскадные сообщения общему получателю
Комментарии
Простую арифметику
Рабочую область, временные и глобальные переменные
Присваивание переменным
Возможно, самое главное, что вам также необходимо знать:
Все, что есть в Smalltalk, является объектом
Каждый объект принадлежит определенному классу, который управляет его поведением
Как я сказал, к настоящему моменту мы охватили, возможно, около 80% языка Smalltalk. Существует очень мало других компьютерных языков, для которых Вы могли бы сделать то же самое в одной главе. Язык Smalltalk является таким маленьким, поскольку он имеет немного простых концепций таких, как Объекты и Сообщения, и применяет их последовательно и повсеместно. Вот почему до сих пор основы действительно легко воспринимались. Тем не менее, остается еще много материала для изучения. Несмотря на то, что язык сам по себе мал, система Smalltalk довольно велика, это то, что делает его богатой и мощной средой для работы.