В Java каждая переменная должна быть непременно объявлена перед ее употреблением. Ведь компилятору необходимо знать, данные какого именно типа содержит переменная, и лишь тогда он сможет правильно скомпилировать оператор, в котором используется переменная. Объявление переменных позволяет также осуществлять строгий контроль типов в Java. Инициализация переменных
Прежде чем использовать переменную в выражении, ей нужно присвоить значение. Сделать это можно, в частности, с помощью уже знакомого вам оператора присваивания. Существует и другой способ: инициализировать переменную при ее объявлении. Для этого достаточно указать после имени переменной знак равенства и требуемое значение. Ниже приведена общая форма инициализации переменной. тип переменная = значение;
где значение обозначает конкретное значение, которое получает переменная при ее создании. А тип значения должен быть совместим с типом переменной. Ниже приведен ряд примеров инициализации переменных. int count = 10; // присвоить переменной count начальное значение 10 char ch = 'S'; // инициализировать переменную ch буквой S float f = 1.2F; // инициализировать переменную f числовым значением 1,2
Присваивать начальные значения переменным можно и в том случае, если в одном операторе объявляется несколько переменных, как в приведенном ниже примере. int а, Ь=8, с =19, d; // инициализируются переменные b и с
В данном случае инициализируются переменные b и с. Динамическая инициализация
В приведенных выше примерах в качестве значений, присваиваемых переменным, использовались только константы. Но в Java поддерживается также динамическая инициализация, при которой можно использовать любые выражения, допустимые в момент объявления переменной. Ниже приведен пример простой программы, в которой объем цилиндра рассчитывается, исходя из его радиуса и высоты. // Демонстрация динамической инициализации, class Dynlnit { public static void main(String args[]) { double radius = 4, height = 5; // Переменная volume инициализируется динамически //во время выполнения программы. double volume = 3.1416 * radius * radius * height; System.out.println("Volume is " + volume); } }
В данном примере используются три локальные переменные: 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, но по завершении кодового блока данного цикла оно теряется.