Январь 2011

Для того чтобы избежать подобных проблем, мы должны объявить переменную currentCalories закрытой (как мы сделали это раньше в классе VirtualPet). Вместо того чтобы позволять внешнему коду непосредственно изменять значение переменной currentCalories, мы добавим один или несколько открытых методов экземпляра, которые могут быть использованы для изменения степени голода каждого животного допустимым способом. Наш класс VirtualPet уже обладает методом eat ( ) для утоления голода животного. Тем не менее этот метод позволяет добавлять любое количество калорий к значению переменной currentCalories. Модифицируем метод eat ( ) класса VirtualPet таким образом, чтобы значение переменной currentCalories не могло превышать 2000:

public function eat (numberOfCalories) { currentCalories += numberOfCalories;

}

Чтобы ограничить максимальное значение переменной currentCalories числом 2 000, мы просто добавим оператор i f в метод е a t ( ), как показано в следующем коде:

public function eat (numberOfCalories) { // Рассчитать новое предложенное количество калорий // для данного животного

var newCurrentCalories = currentCalories + numberOfCalories:

// Если новое предложенное количество калорий для данного животного // больше максимально допустимого значения (то есть 2000)… if (newCurrentCalories > 2000) {

// …присвоить переменной currentCalories максимально

// допустимое значение (2000)

currentCalories = 2000: } else {

// …в противном случае увеличить значение переменной currentCalories // на указанное количество калорий currentCalories = newCurrentCalories:

}

}

Метод eat ( ) класса VirtualPet предоставляет внешнему коду безопасный способ4изменения степени голода выбранного объекта VirtualPet. Однако до сих пор класс VirtualPet не предоставлял внешнему коду никакой возможности для определения степени голода. Чтобы предоставить внешнему коду доступ к этой информации, определим метод getHunger ( ), возвращающий оставшееся количество калорий у объекта VirtualPet, выраженное в процентах. Код нового метода выглядит следующим образом:

public function getHunger ( ) { return currentCalories / 2000;

}

Теперь у нас есть методы для получения и изменения текущей степени голода объекта VirtualPet (getHunger ( ) neat( )). В традиционной терминологии объектно-ориентированного программирования метод, который получает состояние объекта, называетсяметодом-аксессором, или, более неофициально, методом-читателем. С другой стороны, метод, который изменяет состояние объекта, называется методом-мутаторому или, более неофициально, методом-писателем. Тем не менее в языке ActionScript 3.0 термин «метод-аксессор» относится к особой разновидности методов, которые оформляются с использованием синтаксиса чтения и записи значения переменной и рассматриваются далее, в разд. «Get — и set-методы». Как отмечалось ранее, чтобы избежать путаницы в этой книге, мы не будем употреблять традиционные термины «аксессор», «мутатор», «читатель» и «писатель». Вместо этого мы воспользуемся неофициальными терминами метод-получатель и метод-модификатор при обсуждении методов-аксессоров и методов-мутаторов. Более

Того, мы будем применять термины «get-метод» и «set-метод» только в отношении специальных автоматических методов языка ActionScript.

Чтобы немного попрактиковаться в использовании методов-получателей и методов-модификаторов, снова изменим класс VirtualPet. Раньше для получения и присвоения имени объекту VirtualPet мы обращались непосредственно к переменной petName, как показано в следующем коде:

somePet. petName = «Erik»;

Предыдущий подход тем не менее в дальнейшем может стать источником проблем в нашей программе. Он позволяет присваивать переменной petName очень длинные значения, которые могут не вместиться на экране при отображении имени животного. Кроме того, переменной petName может быть присвоена пустая строка (» «), которая вообще не отобразится на экране. Чтобы избежать описанных проблем, объявим переменную petName закрытой и определим метод-модификатор для задания имени животного. Наш метод-модификатор se tName ( ) ограничивает максимальную длину имени 20 символами и предотвращает попытки присвоить переменной petName пустую строку (1111):

public function setName (newName) { // Если длина заданного нового имени больше 20 символов… if (newName. length > 20) {

// …обрезать имя. используя собственный метод String. substr( ).

// возвращающий указанную часть строки, над которой

// выполняется данный метод

newName = newName. substr(0. 20); } else if (newName == «») {

// …в противном случае, если заданное новое имя является

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

// значения переменной petName

return;

}

// Присвоить новое проверенное имя переменной petName petName = newName;

}

Теперь, когда мы объявили переменную petName закрытой, необходимо определить метод-получатель, с помощью которого внешний код сможет получить доступ к имени объекта VirtualPet. Мы присвоим нашему методу-получателю имя getName ( ). Пока этот метод будет просто возвращать значение переменной petName (зачастую возвращение значения переменной экземпляра является единственной задачей метода-получателя). Рассмотрим код метода:

public function getName ( ) { return petName;

}

В настоящее время метод getName ( ) очень прост, однако он добавляет гибкость в нашу программу. Например, в будущем может понадобиться, чтобы имена животных формировались с учетом пола. Для этого мы просто обновим метод, как

показано далее (следующая гипотетическая версия метода getName ( ) предполагает, что в классе VirtualPet определена переменная экземпляра gender, хранящая пол каждого животного):

public function getName ( ) { if (gender == «male») {

return «Mr. » + petName: } else { return «Mrs. » + petName:

}

}

В листинге 3.2 продемонстрирован новый код класса VirtualPet, в который были добавлены определения методов getName ( ) и setName ( ). Для лучшей читабельности метод экземпляра getAge ( ) и переменная экземпляра creationTime были удалены из описания класса VirtualPet.

Листинг 3.2. Класс VirtualPet

package zoo { internal class VirtualPet { private var petName: private var currentCalories = 1000:

public function VirtualPet (name) { petName = name:

}

public function eat (numberOfCalories) { var newCurrentCalories = currentCalories + numberOfCalories: if (newCurrentCalories > 2000) {

currentCalories = 2000: } else {

currentCalories = newCurrentCalories:

}

}

public function getHunger ( ) { return currentCalories / 2000;

}

public function setName (newName) { // Если длина заданного нового имени больше 20 символов… if (newName. length > 20) {

// …обрезать имя

newName = newName. substr(0. 20): } else if (newName == «») {

// …в противном случае, если заданное новое имя является

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

// значения переменной petName

return;

// Присвоить новое проверенное имя переменной petName petName = newName:

}

public function getName ( ) { return petName:

}

}

}

Теперь рассмотрим пример использования наших новых методов getName ( ) и setName ( ):

package zoo { public class VirtualZoo { private var pet:

public function VirtualZoo ( ) { pet = new VirtualPet(«Stan»):

// Присвоить старое имя животного локальной переменной oldName var oldName = pet. getName( ); // Дать животному новое имя pet. setName(«Marcos»);

}

}

}

Используя метод-модификатор для промежуточного присваивания значения переменной, мы можем разрабатывать приложения, способные адекватно реагировать на ошибки времени выполнения путем определения и обработки недопустимых или неподходящих значений. Значит ли это, что доступ ко всем переменным экземпляра должен осуществляться через методы? Например, рассмотрим метод-конструктор нашего класса VirtualPet:

Public function VirtualPet (name) { petName = name:

}

Теперь, когда у нас появился метод для изменения значения переменной petName, должны ли мы модифицировать метод-конструктор класса VirtualPet следующим образом?

public function VirtualPet (name) { setName(name):

}

Ответ зависит от имеющихся условий. Вообще говоря, непосредственное обращение к закрытым переменным, описанным в данном классе, является вполне приемлемым. Тем не менее, если существует вероятность, что имя или роль переменной в будущем будут изменены, или если метод-модификатор или метод-получатель выполняют определенные действия при обращении к переменной (например, проверку на наличие ошибок), имеет смысл применять методы везде, даже внутри класса, в котором описана данная переменная. Например, в предыдущем

модифицированном методе-конструкторе класса VirtualPet разумно присваивать значение переменной petName именно через метод setName ( ), поскольку это гарантирует, что указанное имя не окажется слишком длинным или коротким. И все-таки, в тех случаях, когда решающим фактором является быстродействие, благоразумнее использовать непосредственный доступ к переменной (его получить всегда быстрее, чем доступ через метод).

Программисты, предпочитающие использовать стиль непосредственного доступа к переменным, но при этом не желающие отказываться от преимуществ методов-получателей и методов-модификаторов, обычно применяют автоматические get-и set-методы языка ActionScript, рассматриваемые в следующем разделе.

Get — и set-методы

В предыдущем разделе мы познакомились с методами-получателями и методами-модификаторами, которые представляют собой открытые методы для получения и изменения состояния объекта. Некоторые разработчики считают подобные методы громоздкими. Они утверждают, что конструкция:

pet. setName(«Jeff»):

более неудобна в использовании, чем конструкция: pet. name = «Jeff»:

Чуть раньше мы убедились, что непосредственное присваивание значения переменной, например pet. name = «Jeff», не является идеальной практикой объектно-ориентированного программирования и переменной в конечном счете может быть присвоено некорректное значение. Чтобы устранить несогласованность между удобством использования синтаксиса непосредственного присваивания значения переменной и безопасностью методов-получателей и методов-модификаторов, язык ActionScript поддерживает get — и set-методы. Вызвать эти методы можно с помощью синтаксиса получения или присваивания значения переменной.

Для описания get-метода используется следующий обобщенный синтаксис:

function get имяМетода ( ) { операторы

}

Здесь ключевое слово get указывает на то, что метод является get-методом, имя-Метода представляет имя метода, а операторы — это ноль или более операторов, выполняемых при вызове метода (ожидается, что один из операторов возвращает значение, связанное с методом имяМетода).

Для описания set-метода используется следующий обобщенный синтаксис:

function set имяМетода (новоеЗначение) { операторы

}

Здесь ключевое слово set указывает на то, что метод является set-методом, имяМетода представляет имя метода, параметр новоеЗначение содержит значение, присваиваемое

внутренней переменной экземпляра, а операторы — это ноль или более операторов, выполняемых при вызове метода. Ожидается, что блок операторов операторы определит и внутренне сохранит значение, связанное с методом имяМетода. Обратите внимание, что в теле set-метода оператор return не должен применяться для возврата значения (однако сам по себе он может быть использован для завершения метода). Set-методы автоматически возвращают значение, что рассматривается далее.

Для вызова get — и set-методов применяется уникальный стиль, не требующий использования оператора вызова функции ( ). Get-метод х ( ) объекта ob j вызывается следующим образом:

obj. x:

Но не так:

obj. xC ):

Set-метод у ( ) объекта ob j вызывается следующим образом: obj. y = value: Но не так:

obj. y(value):

Здесь value является первым (и единственным) аргументом, передаваемым в метод у ( ).

Следовательно, get — и set-методы неким магическим образом позволяют преобразовать синтаксис обращения к переменным экземпляра в вызовы методов. В качестве примера (временно) добавим get-метод с именем name ( ) в наш класс

VirtualPet:

public function get name ( ) { return petName;

}

Теперь, когда в классе определен get-метод name ( ), все попытки получить значение переменной экземпляра name на самом деле приведут к вызову этого get-метода. Возвращаемое значение get-метода выглядит так, будто на самом деле было получено значение переменной name. Например, следующий код вызывает get-метод name ( ) и присваивает его возвращаемое значение переменной oldName:

var oldName = pet. name;

Сейчас (временно) добавим set-метод с именем name ( ) в наш класс Vi rtual Pet:

public function set name (newName) { // Если длина заданного нового имени больше 20 символов… if (newName. length > 20) {

// …обрезать имя

newName = newName. substr(0. 20): } else if (newName == «») {

// …в противном случае, если заданное новое имя является

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

// значения переменной petName

return;

// Присвоить новое проверенное имя переменной petName petName = newName;

}

Теперь, когда в классе определен set-метод name ( ), попытки присвоить значение переменной экземпляра name приведут к вызову данного set-метода. Значение, используемое в операторе присваивания переменной name, передается в set-метод, который внутренне сохраняет это значение в закрытой переменной petName. Например, следующий код вызывает set-метод name ( ), который внутренне сохраняет значение 11 Andreas» в переменной petName:

Pet. name = «Andreas»;

После определения get — и set-метода с именем name ( ) переменная name становится всего лишь внешним фасадом. В действительности она не определена в классе, однако обращаться к ней можно так же, как и к любой другой существующей переменной. Таким образом, вы можете считать переменные экземпляра, сопровождаемые get — и set-методами (например, name), псевдопеременными.

Нельзя создавать реальную переменную с именем, совпадающим с названием get — или set-метода. Подобные попытки приведут к ошибке на этапе компиляции.

При вызове set-метода всегда вызывается соответствующий get-метод, результат которого возвращается из данного set-метода. Это позволяет программе использовать новое значение сразу после операции присваивания. Например, следующий код демонстрирует фрагмент приложения музыкального проигрывателя. Для выбора первой воспроизводимой песни используется set-метод. Благодаря вызову метода s t а г t ( ) над возвращаемым значением оператора присваивания переменной firstSong сразу начинается воспроизведение выбранной песни.

// Вызов метода start( ) над объектом new Song(«dancehit. mp3″) -// возвращаемым значением set-метода firstSong( ) (musicPlayer. firstSong = new SongCdancehit. mp3″)) .start( ):

Хотя возможность возвращения значений из set-методов в некоторых случаях оказывается удобной, она накладывает ограничения на get-методы: в частности, get-методы не должны выполнять задачи, которые не требуются для получения значения соответствующей внутренней переменной. Например, с помощью get-метода нельзя реализовать глобальный счетчик, отслеживающий количество обращений к переменной. Автоматический вызов get-метода из set-метода приведет к лишнему увеличению значения счетчика.

Псевдопеременную, обращение к которой происходит с помощью get — и set-метода, можно А щ сделать доступной только для чтения — для этого нужно объявить get-метод и опустить 3?’ объявление set-метода.

Выбор между использованием методов-получателей/-модификаторов и get-/set-методов — дело вкуса. В этой книге, например, get — и set-методы не используются, однако вы можете встретить этот подход в коде других программистов или в другой документации.

Чтобы завершить изучение методов экземпляра, рассмотрим, как обрабатывать неизвестное количество параметров. Для изучения материала следующего раздела необходимо иметь представление о массивах (упорядоченных списках значений), которые еще не рассматривались в этой книге. Если вы незнакомы с массивами, пока пропустите этот раздел и вернитесь к нему после прочтения гл. 11.

I Методики, описанные в следующем разделе, применимы не только к методам экземпля-л* ра, но и к статическим методам и функциям, которые будут рассмотрены в следующих ц?’ главах.

Обработка неизвестного количества параметров

Как известно из гл. 1, нельзя вызвать метод, не указав аргументы для всех обязательных параметров. Нельзя также вызывать метод, если указано больше аргументов, чем требуется.

Чтобы определить метод, который принимает произвольное количество аргументов, используется параметр. . . (rest). Он описывает массив, содержащий все аргументы, передаваемые в данный метод. Этот параметр может использоваться как самостоятельно, так и в сочетании с именованными параметрами. Когда параметр…(rest) используется отдельно, описание метода имеет следующий обобщенный вид:

function имяМетода (…массивАргументов) { }

В предыдущем коде имяМетода обозначает имя метода (или функции), а массивАргументов представляет имя параметра, присваиваемое автоматически создаваемому массиву, который содержит все передаваемые в данный метод аргументы. Первый аргумент (крайний левый в выражении вызова) хранится под индексом 0, и обратиться к нему можно с помощью выражения массивАргументовЩ. Последующие аргументы сохраняются по порядку слева направо. Таким образом, для обращения ко второму аргументу используется выражение массивАргументов\_У]у к третьему — выражение массивАргументов{Т\ и т. д.

Параметр… (rest) позволяет создавать очень гибкие функции, оперирующие произвольным количеством значений. Например, следующий код демонстрирует метод, который определяет среднее значение любых чисел, передаваемых в качестве аргументов:

public function getAverage (…numbers) { var total = 0;

for (var i = 0: i < numbers.length: i++) { total += numbers [i];

}

return total / numbers. length;

Обратите внимание, что представленный метод getAverage ( ) работает только с числовыми аргументами. Чтобы защитить этот метод от использования нечисловых аргументов, можно применить оператор is, рассматриваемый вподразд. «Восходящее и нисходящее приведения типов» разд. «Приведение типов» гл. 8.

Параметр. . . (rest) также может использоваться в сочетании с именованными параметрами. В этом случае он должен быть последним в списке параметров. Например, рассмотрим метод initializeUser( ), применяемый для инициализации пользователя в гипотетическом социальном сетевом приложении. В описании метода определяется один обязательный параметр name, за которым следует параметр. . . (rest) с именем hobbies:

public function initializeUser (name, …hobbies) { }

При вызове метода initializeUser ( ) мы обязаны указать аргумент для параметра name и при желании можем указать дополнительный список хобби, разделяя элементы списка запятыми. Внутри метода параметру name присваивается значение первого переданного аргумента, а параметру hobbies — массив всех оставшихся аргументов. Например, если вызвать данный метод следующим образом:

initializeUser(«Hoss». «video games», «snowboarding»);

то параметру name будет присвоено значение «Hoss «, а параметру hobbies — значение ["video games", "snowboarding"].

Далее: информация и поведение на уровне класса

Мы рассмотрели методы и переменные экземпляра. Как известно из гл. 1, они определяют поведение и характеристики объектов класса. Из следующей главы вы узнаете, как создавать поведение и управлять информацией, относящейся не к отдельным объектам, а ко всему классу.

ПИВА 4

Статические переменные

и методы

Из гл. 1 вы узнали, как определять характеристики и поведение объекта с помощью переменных и методов экземпляра. В этой главе вы познакомитесь с тем, как организовывать информацию и создавать функциональность, относящуюся к самому классу, а не к его экземплярам.

Статические переменные

При изучении материала предыдущих глав мы немного попрактиковались в использовании переменных экземпляра, которые представляют собой переменные, связанные с определенным экземпляром класса. В отличие от них, статические переменные связаны с самим классом, а не с его определенным экземпляром. Статические переменные применяются для хранения информации, относящейся логически ко всему классу, в отличие от информации, которая меняется от одного экземпляра к другому. Например, в классе, представляющем окно, статическая переменная может использоваться для указания размера по умолчанию для новых экземпляров этого окна, а в классе, представляющем автомобиль в гоночной игре, с помощью статической переменной можно задать максимальную скорость для всех экземпляров этого автомобиля.

Подобно переменным экземпляра, для создания статических переменных применяются описания переменных, размещаемые внутри класса, однако описание статической переменной должно также*включать атрибут static, как показано в следующем обобщенном коде:

class НекийКласс { static var идентификатор = значение;

}

Как и в случае с переменными экземпляра, для управления доступностью статических переменных в программе можно использовать модификаторы управления доступом. Такие модификаторы идентичны модификаторам, применяемым в описаниях переменных экземпляра, — public, internal, protected и private. Если в описании переменной никакой модификатор не задан, то используется модификатор internal (доступ внутри пакета). Указываемый модификатор обычно размещается перед атрибутом static, как показано в следующем коде:

class НекийКласс { private static var идентификатор = значение;

Для доступа к статической переменной указывается имя класса, содержащего определение данной переменной, за которым следует точка (.) и имя переменной, как показано в следующем обобщенном коде:

НекийКласс. идентификатор = значение;

Внутри класса, в котором объявлена данная переменная, имя идентификатор может использоваться и самостоятельно (без лидирующего имени класса и точки). Например, в классе А, в котором определена статическая переменная v, выражение А. v идентично выражению v. Тем не менее, чтобы различать статические переменные и переменные экземпляра, многие разработчики (это относится и к примерам данной книги) включают лидирующее имя класса даже в тех случаях, когда его использование не является обязательным.

Статические переменные и переменные экземпляра с одинаковыми именами могут сосуществовать внутри одного класса. Если в классе А определена переменная экземпляра v и статическая переменная с таким же именем, то при вызове в виде v идентификатор будет ссылаться на переменную экземпляра, а не на статическую переменную. Обратиться к статической переменной можно только путем указания лидирующего имени класса: А. v. В этом случае говорят, что переменная экземпляра затеняет статическую переменную.

Теперь добавим несколько статических переменных в наш класс VirtualPet. Как известно, статические переменные используются для хранения информации, которая логически относится ко всему классу и не меняется от одного экземпляра к другому. В нашем классе VirtualPet уже есть два примера подобной информации: максимальная длина имени животного и максимальное количество калорий, которое может принять данное животное. Для хранения этой информации добавим две новые статические переменные: maxNameLength и maxCalories. Мы не будем обращаться к нашим переменным за пределами класса VirtualPet, поэтому объявим их с использованием модификатора доступа private. Следующий код демонстрирует объявления переменных maxNameLength и maxCalories, при этом оставшаяся часть кода класса VirtualPet опущена ради краткости:

package zoo { internal class VirtualPet { private static var maxNameLength = 20; private static var maxCalories = 2000;

// Оставшаяся часть класса не показана…

}

}

Теперь, когда у нас есть переменные maxNameLength и maxCalories, мы можем модифицировать методы getHunger ( ), еаt ( ) и setName ( ), чтобы воспользоваться этими переменными. В листинге 4.1 продемонстрирована последняя версия класса VirtualPet, в который были добавлены статические переменные. Изменения, внесенные в предыдущую версию кода, выделены полужирным шрифтом. Обратите внимание, что по соглашению статические переменные класса перечислены перед переменными экземпляра.

/

Статические переменные

117

Листинг 4.1. Класс VirtualPet

package zoo { internal class VirtualPet { private static var maxNameLength = 20; private static var maxCalories = 2000;

private var petName;

// Изначально каждому животному дается 50 % от максимально

// возможного количества калорий.

private var currentCalories = VirtualPet. maxCalories/2;

public function VirtualPet (name) { setName(name):

}

public function eat (numberOfCalories) { var newCurrentCalories = currentCalories + numberOfCalories; if (newCurrentCalories > VirtualPet. maxCalories) {

currentCalories = Virtual Pet. maxCalories; } else {

currentCalories = newCurrentCalories;

}

}

public function getHunger ( ) { return currentCalories / Virtual Pet. maxCalories;

}

public function setName (newName) { // Если длина заданного нового имени больше maxNameLength символов… if (newName. length > Virtual Pet. maxNameLength) { // …обрезать имя

newName = newName. substr(0. VirtualPet. maxNameLength); } else if (newName == «») { // …в противном случае, если заданное новое имя является // пустой строкой, завершить выполнение метода, не изменяя // значения переменной petName return;

}

// Присвоить новое проверенное имя переменной petName petName = newName;

}

public function getName ( ) { return petName;

}

}

Если проанализировать листинг 4.1, то можно заметить, что наличие переменных maxNameLength и maxCalories помогает централизовать код. Например,

ранее, чтобы изменить максимально допустимое количество символов в имени, нам пришлось бы заменить число 20 в двух местах тела метода setName — этот процесс не только отнимает много времени, но и может привести к ошибке. Теперь, чтобы изменить максимально допустимое количество символов, нужно просто присвоить другое значение переменной maxNameLength, и весь класс обновится автоматически.

**4

Необъяснимые константные значения, как, например, число 20 в предыдущей версии метода setName(), называются «магическими значениями», поскольку они играют некую 3?«’ важную роль, однако их назначение неочевидно. Избегайте использования магических значений в своем коде. В большинстве случаев статические переменные могут применяться для хранения значений, которые в противном случае будут «магическими».

Статические переменные зачастую используются для хранения установочных параметров, значения которых не должны изменяться после запуска программы. Чтобы исключить возможность изменения значения переменной, ее нужно объявить константой, о чем и пойдет речь в следующем разделе.

Константы

Константа — это переменная экземпляра, статическая или локальная переменная, значение которой после инициализации остается постоянным вплоть до завершения программы. Для создания константы применяется стандартный синтаксис описания переменной, однако вместо ключевого слова var используется ключевое слово const. По соглашению имена констант полностью состоят из прописных букв. Чтобы создать константную статическую переменную, прямо в теле класса можно использовать следующий обобщенный код:

static const ИДЕНТИФИКАТОР = значение

Для создания константной переменной экземпляра прямо в теле класса можно указать следующий обобщенный код:

const ИДЕНТИФИКАТОР = значение

Чтобы создать константную локальную переменную, в теле метода или функции можно использовать следующий обобщенный код:

const ИДЕНТИФИКАТОР = значение

В трех предыдущих примерах кода ИДЕНТИФИКАТОР обозначает имя константы, а значение — начальное значение переменной. В случае с константными статическими и константными локальными переменными, после того как значение значение, указанное в инициализаторе переменной, будет присвоено переменной, изменить ее будет невозможно.