 |
Булевские константы. Символьные константы. Строковые константы. Область определения и время существования переменных
|
|
|
|
Булевские константы
Булевские константы очень просты. Значений типа Boolean может существовать только два: true и false. Эти значения не преобразуются ни в какие числовые представления. В Java константа true не равна 1, а константа false не равна 0. В Java эти значения могут быть присвоены только тем переменным, которые объявлены как boolean, или использоваться в выражениях с булевскими операциями.
Символьные константы
В Java символы представляют собой индексы в наборе символов Unicode. Это 16-битные значения, которые могут быть преобразованы в целые значения, и по отношению к которым можно выполнять целочисленные операции, такие как операции сложения и вычитания. Символьные константы указываются внутри пары одинарных кавычек. Все отображаемые символы ASCII можно вводить непосредственно, указывая их в кавычках, например 'a', 'z' и '@'. Для ввода символов, непосредственный ввод которых невозможен, можно использовать несколько управляющих последовательностей, которые позволяют вводить нужные символы, такие как '\'' для символа одинарной кавычки и '\n' для символа новой строки. Существует также механизм для непосредственного ввода значения символа в восьмеричном или шестнадцатеричном виде. Для ввода значения в восьмеричной форме используют символ обратной косой черты, за которым следует трехзначный номер. Например, последовательность '\141' эквивалентна букве 'a'.
Для ввода шестнадцатеричного значения применяются символы обратной косой черты и u (\u), за которыми следуют четыре шестнадцатеричные цифры.
· \ddd Восьмеричный символ (ddd)
· \uxxxx Шестнадцатеричный символ Unicode (xxxx)
· \' Одинарная кавычка
· \" Двойная кавычка
· \\ Обратная косая черта
|
|
|
· \r Возврат каретки
· \n Новая строка (этот символ называют также символом перевода строки)
· \f Подача страницы
· \t Табуляция
· \b Возврат на одну позицию
Строковые константы
Указание строковых констант в Java осуществляется так же, как в других языках – путем заключения последовательности символов в пару двойных кавычек. Вот несколько примеров строковых констант:
" Hello World"
" two\nlines"
" \" This is in quotes\" "
Управляющие символы и восьмеричная/шестнадцатеричная формы записи, определенные для символьных констант, работают точно так же и внутри строковых констант.
Важно отметить, что в Java строки должны начинаться и заканчиваться в одной строке. В этом языке отсутствует какой-либо управляющий символ продолжения строки, подобный тем, что имеются в ряде других языков.
Область определения и время существования переменных
До сих пор все использованные в примерах переменные были объявлены в начале метода main(). Однако Java допускает объявление переменных внутри любого блока. Как было сказано ранее, блок начинается открывающей фигурной скобкой и завершается закрывающей фигурной скобкой. Блок задает область определения. Таким образом, при открытии каждого нового блока мы создаем новую область определения. Область определения задает то, какие объекты видимы другим частям программы. Она определяет также время существования этих объектов.
Многие другие языки программирования различают две основных категории областей определения: глобальную и локальную. Однако эти традиционные области определения не очень хорошо вписываются в строгую объектно-ориентированную модель Java.
Хотя глобальную область определения и можно задать, в настоящее время такой подход является скорее исключением, нежели правилом. В Java две основных области определения – это определяемая классом и определяемая методом. Но даже это разделение несколько искусственно. Однако поскольку область определения класса обладает несколькими уникальными свойствами и атрибутами, не применимыми к области определения метода, такое разделение имеет определенный смысл.
|
|
|
Определенная методом область определения начинается с его открывающей фигурной скобки. Однако если данный метод обладает параметрами, они также включаются в область определения метода.
Основное правило, которое следует запомнить: переменные, объявленные внутри области определения, не видны (т. е. недоступны) коду, который находится за пределами этой области. Таким образом, объявление переменной внутри области определения ведет к ее локализации и защите от несанкционированного доступа и/или изменений. Действительно, правила обработки области определения – основа инкапсуляции.
Области определения могут быть вложенными. Например, при каждом создании блока кода мы создаем новую, вложенную область определения. В этих случаях внешняя область определения заключает в себя внутреннюю область. Это означает, что объекты, объявленные во внешней области, будут видны коду, определенному во внутренней области. Тем не менее, обратное не верно. Объекты, которые объявлены во внутренней области определения, не будут видны за ее пределами.
Чтобы понять эффект применения вложенных областей определения рассмотрим следующую программу:
// Демонстрация области определения блока.
class Scope {
public static void main(String args[]) {
int x; // эта переменная известна всему коду внутри метода main
x = 10;
if(x == 10) { // начало новой области определения
int y = 20; // известной только этому блоку
// и x, и y известны в этой области определения.
System. out. println(" x и y: " + x + " " + y);
x = y * 2;
}
// y = 100; // Ошибка! y не известна в этой области определения
// переменная x известна и здесь.
System. out. println(" x равна " + x);
}
}
Как видно из комментариев, переменная x объявлена в начале области определения метода main() и доступна всему последующему коду, находящемуся внутри этого метода.
Объявление переменной y осуществляется внутри блока if. Поскольку блок задает область определения, переменная y видна только коду внутри этого блока. Именно поэтому строка y=100;, расположенная вне этого блока, помещена в комментарий. Если удалить символ комментария, это приведет к ошибке времени компиляции, поскольку переменная y не видна за пределами своего блока. Переменную x можно использовать внутри блока if, поскольку код внутри блока (т. е. во вложенной области определения) имеет доступ к переменным, которые объявлены внешней областью.
|
|
|
Внутри блока переменные можно объявлять в любом месте, но они становятся допустимыми только после объявления. Таким образом, если переменная объявлена в начале метода, она доступна всему коду внутри этого метода. И наоборот, если переменная объявлена в конце блока, она, по сути, бесполезна, поскольку никакой код не получит к ней доступ. Например, следующий фрагмент кода неправилен, поскольку переменную count нельзя использовать до ее объявления:
// Этот фрагмент неправилен!
count = 100; // Стоп! Переменную count нельзя использовать до того,
// как она будет объявлена!
int count;
Следует запомнить еще один важный нюанс: переменные создаются при входе в их область определения и уничтожаются при выходе из нее. Это означает, что переменная утратит свое значение сразу по выходу из области определения. Следовательно, переменные, которые объявлены внутри метода, не будут хранить свои значения между обращениями к этому методу. Кроме того, переменная, объявленная внутри блока, будет утрачивать свое значение по выходу из блока. Таким образом, время существования переменной ограничено ее областью определения.
Если объявление переменной содержит инициализацию, инициализация переменной будет повторяться при каждом вхождении в блок, в котором она объявлена. Например, рассмотрим приведенную ниже программу.
// Демонстрация времени существования переменной.
class LifeTime {
public static void main(String args[]) {
int x;
for(x = 0; x < 3; x++) {
int y = -1; // y инициализируется при каждом вхождении в блок
System. out. println(" y равна: " + y); // эта строка всегда выводит
// значение -1
y = 100;
System. out. println(" y теперь равна: " + y);
}
}
}
Эта программа генерирует следующий вывод:
|
|
|
y равна: -1
y теперь равна: 100
y равна: -1
y теперь равна: 100
y равна: -1
y теперь равна: 100
Как видите, переменная y повторно инициализируется значением –1 при каждом вхождении во внутренний цикл for. Несмотря на то что впоследствии переменной присваивается значение 100, это значение теряется.
И последнее: хотя блоки могут быть вложенными, во внутреннем блоке нельзя объявлять переменные с тем же именем, что и во внешней области. Например, следующая программа ошибочна:
// Компиляция этой программы будет невозможна
class ScopeErr {
public static void main(String args[]) {
int bar = 1;
{ // создание новой области определения
int bar = 2; //Ошибка времени компиляции – переменная bar уже определена!
}
}
}
|
|
|
