Java: руководство для начинающих
Шрифт:
где значение обозначает конкретное значение, которое получает переменная при ее создании. А тип значения должен быть совместим с типом переменной. Ниже приведен ряд примеров инициализации переменных. int count = 10; // присвоить переменной count начальное значение 10 char ch = 'S'; // инициализировать переменную ch буквой S float f = 1.2F; // инициализировать переменную f числовым значением 1,2
Присваивать начальные значения переменным можно и в том случае, если в одном операторе объявляется несколько переменных, как в приведенном ниже примере. int а, Ь=8, с =19, d; // инициализируются переменные b и с
В данном случае инициализируются переменные b и с. Динамическая инициализация
В приведенных выше примерах в качестве значений, присваиваемых переменным,
В данном примере используются три локальные переменные: radius, height и volume. Первые две из них инициализируются константами, а для присвоения значения переменной volume применяется динамическая инициализация, в ходе которой вычисляется объем цилиндра. В выражении динамической инициализации можно использовать любой определенный к этому моменту элемент, в том числе вызовы методов, другие переменные и литералы. Область и срок действия переменных
Все использовавшиеся до сих пор переменные объявлялись в начале метода main . Но в Java можно объявлять переменные в любом кодовом блоке. Как пояснялось в главе 1, кодовый блок начинается с открывающей фигурной скобки и оканчивается закрывающей фигурной скобкой. Блок определяет область действия переменных. Начиная новый блок, вы всякий раз создаете новую область действия. По существу, область действия определяет доступность объектов из других частей программы и срок их действия.
Во многих языках программирования поддерживаются две общие категории областей действия: глобальная и локальная. И хотя они поддерживаются и в Java, тем не менее не относятся к самым лучшим средствам для определения пределов действия объектов. Намного большее значение в Java имеют области, определяемые классом и методом. Об областях действия, определяемых классом (и объявляемых в них переменных), речь пойдет далее в этой книге, когда дойдет черед до рассмотрения классов. А до тех пор исследуем только те области действия, которые определяются методами или в самих методах.
Начало области действия, определяемой методом, обозначает открывающая фигурная скобка. Если для метода предусмотрены параметры, они также входят в область его действия.
Как правило, переменные, объявленные в некоторой области действия, не видны (а следовательно, недоступны) за ее пределами. Следовательно, объявляя переменную в некоторой области действия, вы тем самым ограничиваете пределы ее действия и защищаете ее от нежелательного доступа и видоизменения. На самом деле правила определения области действия служат основанием для инкапсуляции.
Области действия могут быть вложенными. Открывая новый кодовый блок, вы создаете новую, вложенную область действия. Такая область заключена во внешней области. Это означает, что объекты, объявленные во внешней области действия, будут доступны для кода во внутренней области, но не наоборот. Объекты, объявленные во внутренней области действия, недоступны во внешней области.
Для того чтобы лучше понять принцип действия вложенных областей действия, рассмотрим следующий пример программы: // Демонстрация области действия кодового блока, class ScopeDemo { public static void main(String args[ ] ) { int x; // эта переменная доступна для всего кода в методе main. х = 10; if(х == 10) { // Начало новой области действия. int у = 20; // Эта переменная доступна только в данном кодовом блоке. // Обе переменные, х и у, доступны в данном кодовом блоке. System, out .println ("х and у: " + х + " 11 + у) ; х = у * 2; } // у = 100; // Ошибка! Переменная у недоступна эа пределами // области своего действия // А переменная х по-прежнему доступна. System.out.println("х is " +
х); } }Как следует из комментариев к приведенной выше программе, переменная х определяется в начале области действия метода main и доступна для всего кода, содержащегося в этом методе. В блоке условного оператора if объявляется переменная у. Этот блок определяет область действия переменной у, и, следовательно, она доступна только в нем. Именно поэтому закомментирована строка кода у = 100;, находящаяся за пределами данного блока. Если удалить символы комментариев, то при компиляции программы появится сообщение об ошибке, поскольку переменная у недоступна для кода за пределами ее блока. В то же время в блоке условного оператора i f можно пользоваться переменной х, потому что код в блоке, который определяет вложенную область действия, имеет доступ к переменным из внешней, охватывающей его области действия.
Переменные можно объявлять в любом месте кодового блока, но сделать это следует непременно перед тем, как пользоваться ими. Именно поэтому переменная, определенная в начале метода, доступна для всего кода этого метода. А если объявить переменную в конце блока, то такое объявление окажется, по существу, бесполезным, поскольку переменная станет вообще недоступной для кода.
Следует также иметь в виду, что переменные, созданные в области их действия, удаляются, как только управление в программе передается за пределы этой области. Следовательно, после выхода из области действия переменной содержащееся в ней значение теряется. В частности, переменные, объявленные в теле метода, не хранят значения в промежутках между последовательными вызовами этого метода. Таким образом, срок действия переменной ограничивается областью ее действия.
Если при объявлении переменной осуществляется ее инициализация, то переменная будет повторно инициализироваться при каждом входе в тот блок, в котором она объявлена. Рассмотрим в качестве примера следующую программу: // Демонстрация срока действия переменной, class VarlnitDemo { public static void main(String args[]) { int x; for(x = 0; x < 3; x++) { int у = -1; // переменная у инициализируется при каждом входе в блок System.out.println("у is: 11 + у); // всегда выводится значение -1 у = 100; System.out.println("у is now: " + у); } } }
Ниже приведен результат выполнения данной программы. У is: -1 у is now: 100 у is: -1 у is now: 100 у is: : -1 у is now: 100
Как видите, на каждом шаге цикла for переменная у инициализируется значением -1. Затем ей присваивается значение 100, но по завершении кодового блока данного цикла оно теряется.
Для правил области действия в Java характерна следующая особенность: имя переменной во вложенном блоке не может совпадать с именем переменной во внешнем блоке. Рассмотрим следующий пример программы. В ней предпринимается попытка объявить две переменные с одним и тем же именем в разных областях действия, и поэтому она не подлежит компиляции. /* В этой программе предпринимается попытка объявить переменную во внутренней области действия с таким же именем, как и у переменной, определенной во внешней области действия. *** Эта программа не подлежит компиляции. *** */ class NestVar { public static void main(String args[]) { int count; // Первое объявление переменной count for (count = 0; count < 10; count = count+1) { System.out.println("This is count: " + count); int count; // Второе объявление переменной count. // Недопустимо, поскольку точно такая же // переменная объявлена раньше!!! for(count = 0; count < 2; count++) System.out.println("This program is in error!"); } } }
Если у вас имеется некоторый опыт программирования на С или C++, то вам, вероятно, известно, что в этих языках отсутствуют какие-либо ограничения на имена переменных, объявляемых во внутренней области действия. Так, в С и C++ объявление переменной count в блоке внешнего цикла for из приведенного выше примера программы вполне допустимо, несмотря на то, что такая же переменная уже объявлена во внешнем блоке. В этом случае переменная во внутреннем блоке скрывает переменную из внешнего блока. Создатели Java решили, что подобное сокрытие имен переменных может привести к программным ошибкам, и поэтому запретили его. Операторы