Тип и значение переменной java. Примитивные типы Java

Тип данных определяется тремя составляющими:

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

Какие бывают типы данных в Java?

Язык программирования содержит некоторые заранее определенные встроенные типы и позволяет программистам определять свои собственные, пользовательские.

В Java типы данных делятся на примитивные и ссылочные.

«Примитивный» означает, что дальнейшее его деление невозможно. Расширять или изменять его язык программирования не позволяет. Такой тип данных описывается примитивными и другими пользовательскими типами.

Переменная примитивного типа содержит значение, а ссылочная - адрес объекта в памяти.

Язык Java. время и дата

Составные данные делятся на классы, интерфейсы и массивы. Членами интерфейсного типа являются абстрактные методы и константы. В языке Java типы данных дата и время задаются конструктором Date():

• d = new Date().

Язык Java. Типы данных: String

Строка представляет собой класс, определенный в и он может быть использован для работы с текстом (последовательностью символов).

Объявление ссылочной String-переменной следующее: String str.

• str = new String ("Привет").

Что происходит при выполнении этого кода? Во-первых, выделяется память, и имя str связывается с этой ячейкой памяти. Это не отличается от объявления примитивной переменной. Второй фрагмент кода создает в памяти объект String с текстом «Привет» и сохраняет ссылку на него (или адрес памяти) в str.

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

• String str1;
• String str2;
• str1 = new String ("Привет");
• str2 = str1;

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

• String str1 = "Hello".

Примитивные типы данных Java - byte, short, int, long, char, float, double и boolean. Они делятся на две категории: логическую и числовую. Последняя может быть разделена на целые числа и числа с плавающей точкой.

Целые типы данных Java представляют собой числовые типы, значения которых являются целыми числами. Их пять: byte, short, int, long и char.

Int

Int представляет собой 32-разрядный знаковый примитивный тип данных. Переменная занимает 32 бита памяти. Допустимый диапазон - от -2147483648 до 2147483647 (-2 31 до 2 31 - 1). Все целые числа в этом диапазоне являются целочисленными литералами или константами. Например, 10, -200, 0, 30, 19 являются литералами int. Их можно присвоить переменной int:

• int num1 = 21;

Целые литералы могут быть выражены в виде двоичного, восьмеричного, десятичного и шестнадцатеричного числа.

Когда литерал начинается с нуля и имеет, по крайней мере, две цифры, он считается записанным в восьмеричном формате. 0 и 00 представляют одинаковое значение - ноль.

Все литералы int в формате шестнадцатеричного числа начинаются с 0x или 0x, и они должны содержать хотя бы одну шестнадцатеричную цифру:

• int num1 = 0x123.

Int-литералы в формате начинаются с 0b или 0B:

• int num1 = 0b10101.

Long

Это 64-разрядный знаковый примитивный тип. Используется, когда результат вычислений может превышать диапазон int. Диапазон long - от -2 63 до 2 63 - 1. Все целые числа этого диапазона являются литералами длинного типа.

Чтобы отличать в языке Java типы данных int и long, литерал последнего типа всегда заканчивается L или l.

Целые литералы длинного типа также могут быть выражены в восьмеричном, шестнадцатеричном и двоичном форматах.

Когда long-литерал присваивается переменной long, компилятор Java проверяет присваиваемое значение и удостоверяется, что оно находится в приемлемом диапазоне; в противном случае произойдет ошибка компиляции.

Поскольку диапазон int меньше, чем у long, значение int-переменной всегда может быть присвоено переменной типа long. Но обратное присвоение невозможно даже в пределах диапазона int. Для этого используется явное указание:

• num1 = (int) num2;

Byte

Byte представляет собой 8-разрядный целый примитивный тип. Его диапазон - от -128 до 127 (-2 7 до 2 7 - 1). Это наименьший целый тип, имеющийся в Java. Как правило, байтовые переменные используются, когда в программе задействовано много значений в диапазоне от -128 до 127, или при работе с бинарными данными. В отличие от литералов int и long, byte-литералы отсутствуют. Тем не менее можно назначить byte-переменной любой int-литерал, так как он перекрывает диапазон байта.

Если значение переменной выходит за пределы диапазона, Java выдаст ошибку компилятора.

Кроме того, можно присвоить только int-литерал, но не значение, хранящееся в переменной int, так как при этом возможна потеря точности. Для этого потребуется явное приведение типа.

• b1 = (byte) num1.

Short

Представляет собой 16-разрядный знаковый целый примитивный тип данных. Его диапазон - от -32768 до 32767 (или -2 15 до 2 15 - 1).

Как правило, необходимость в коротких переменных возникает, когда программа использует большое количество значений, которые не превышают указанный диапазон. Short-литерал отсутствует, но возможно присвоение любого литерала int в пределах диапазона short. Значение byte-переменной может быть присвоено всегда. Остальные правила присвоения int или long short-переменной такие же, как для byte.

Char

Char является 16-разрядным беззнаковым примитивным типом данных, который представляет символ Юникода. Отсутствие знака означает, что переменная не может иметь отрицательное значение. Диапазон - от 0 до 65535, что совпадает с кодировкой набора символов Юникода. Литерал представляет значение char и может быть выражен в таких формах:

• символ, заключенный в одинарные кавычки;
• последовательность управляющих символов;
• последовательность управляющих символов юникода;
• последовательность восьмеричных управляющих символов.

Символ может быть выражен путем заключения его в одинарные кавычки: char C1 = "A". обозначают строковый литерал, который не может быть присвоен char-переменной, даже если строка состоит только из одного символа. Это недопустимо, так как ссылка примитивной переменной не присваивается. Все строковые литералы являются объектами класса String и, следовательно, ссылками, тогда как символьные относятся к примитивному типу.

Литерал, выраженный управляющей последовательностью, записывается в виде обратной косой черты с символом в одиночных кавычках. Всего их 8: ‘\n’, ‘\r’, ‘\f’, ‘\b’, ‘\t’, ‘\\’, ‘\”’, ‘\’’.

Управляющая юникод-последовательность имеет вид "\uxxxx", где \u (обратный слеш, за которым следует строчная u) обозначает ее начало, а хххх представляет ровно четыре шестнадцатеричные цифры кода символа в системе Юникод. Например, "A" имеет значение 65 в десятичной системе и 41 в шестнадцатеричной. Таким образом, этот символ может быть представлен как "\u0041".

Восьмеричная управляющая последовательность записывается в виде "\nnn", где n - восьмеричная цифра (0-7). Диапазон значений - от "\000" до "\377", где 377 8 соответствует 255 10 . Поэтому она используется для представления символов с кодом от 0 до 255, необходимого для совместимости с другими языками программирования. В отличие от юникод-последовательности, где необходимы все четыре шестнадцатеричные цифры, здесь можно использовать 1, 2 или 3 восьмеричные: "\n", "\nn" или "\nnn".

Логический тип

Boolean имеет только два действительных значения: true (истина) и false (ложь). Они называются булевыми литералами. Логическая переменная не может быть приведена к другому типу и наоборот. Java не определяет размер boolean - он зависит от конкретной реализации виртуальной Java- машины.

Типы данных Java с плавающей точкой

Число, которое содержит дробную часть, в памяти компьютера может храниться в представлении с фиксированным количеством цифр до и после точки или с указанием ее положения. Так как количество цифр может меняться, то говорят, что точка «плавает».

В языке Java типы данных с плавающей точкой используют 32 бита. Согласно стандарту IEEE 754, это соответствует одинарной точности, которая позволяет представлять, например, числа 1,4 х 10 -45 и 3,4 х 10 38 , причем как положительные, так и отрицательные.

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

• float f1 = 3.25F;
• float f2 = 32.5E-1F;
• float f3= 0.325E + 1F.

Тип определяет два нуля: +0.0F (или 0.0F) и -0.0F. Однако для целей сравнения оба нуля считаются равными. Кроме того, им определены два вида бесконечности: положительная и отрицательная. Результаты некоторых операций (например, не определены и представлены специальным значением NaN.

Двойная точность

Для хранения чисел с плавающей точкой double использует 64 бита. Число двойной точности может представлять положительные и отрицательные значения величиной 4,9 х 10 -324 и 1,7 х 10 308 .

Все действительные числа по умолчанию являются двойными литералами. По желанию могут явно обозначаться суффиксом d или D, например, 19.27d. Двойной литерал может быть выражен в десятичной форме и в научной нотации.

Переменная предоставляется нам именем хранения, чтобы нашей программой можно было манипулировать. Каждая переменная в Java имеет конкретный тип, который определяет размер и размещение её в памяти; диапазон значений, которые могут храниться в памяти; и набор операций, которые могут быть применены к переменной.

Необходимо объявить все переменные, прежде чем их использовать. Ниже показана основная форма объявления:

Тип данных переменная [ = значение], [переменная [= значение], ...] ;

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

Ниже приведены примеры объявления переменной и инициализации в Java:

Int a, b, c; // Объявление трех целых a, b, и c. int a = 10, b = 10; // Пример инициализации. byte b = 22; // Инициализация переменной b типа byte. double pi = 3.14159; // Объявление и присвоение величины пи. char a = "a"; // Переменной a типа char присваивается значение "a".

В этом уроке рассмотрим различные типы переменных, доступных в языке Java. Существует три типа переменных :

• локальные переменные;
• переменные экземпляра;
• статические переменные или переменные класса.

Локальные переменные в Java

• Локальные переменные объявляются в методах, конструкторах или блоках.
• Локальные переменные создаются, когда метод, конструктор или блок запускается и уничтожаются после того, как завершиться метод, конструктор или блок.
• Модификаторы доступа нельзя использовать для локальных переменных.
• Они являются видимыми только в пределах объявленного метода, конструктора или блока.
• Локальные переменные реализуются на уровне стека внутри.
• В Java не существует для локальных переменных значения по умолчанию , так что они должны быть объявлены и начальное значение должны быть присвоено перед первым использованием.

Пример

«age» - локальная переменная, определяется внутри метода «pupAge()» и области её действия ограничивается только этим методом.

Public class Test{ public void pupAge(){ int age = 0; age = age + 7; System.out.println("Возраст щенка: " + age); } public static void main(String args){ Test test = new Test(); test.pupAge(); } }

Будет получен следующий результат:

Возраст щенка: 7

Пример без инициализации

Пример использования «age» без инициализации. Программа выдаст ошибку во время компиляции.

Public class Test{ public void pupAge(){ int age; age = age + 7; System.out.println("Возраст щенка: " + age); } public static void main(String args){ Test test = new Test(); test.pupAge(); } }

Это приведёт к следующему сообщению об ошибке во время компиляции:

Test.java:4:variable number might not have been initialized age = age + 7; ^ 1 error

Переменные экземпляра

• Переменные экземпляра объявляются в классе, но за пределами метода, конструктора или какого-либо блока.
• Когда для объекта в стеке выделяется пространство, создается слот для каждого значения переменной экземпляра.
• В Java переменные экземпляра создаются тогда, когда объект создан с помощью ключевого слова «new» и разрушаются тогда, когда объект уничтожается.
• Переменные содержат значения, которые должны ссылаться более чем на один метод, конструктор или блок, или на основные части состояния объекта, которые должны присутствовать на протяжении всего класса.
• Переменные экземпляра могут быть объявлен на уровне класса, до или после использования.
• Модификаторы доступа могут быть предоставлены для переменных экземпляра.
• Переменные экземпляра в Java являются видимыми для всех методов, конструкторов и блоков в классе. Как правило рекомендуется сделать их private (уровень доступа). Однако можно сделать их видимыми для подклассов этих переменных с помощью модификаторов доступа.
• Переменные экземпляра имеют значения по умолчанию. Для чисел по умолчанию равно 0, для логических - false, для ссылок на объект - null. Значения могут быть присвоены при объявлении или в конструкторе.
• Переменные экземпляра в Java могут быть доступны непосредственно путем вызова имени переменной внутри класса. Однако в статических методах и различных класса (когда к переменным экземпляра дана доступность) должны быть вызваны используя полное имя - ObjectReference.VariableName .

Пример

import java.io.*; public class Employee{ // Переменная экземпляра открыта для любого дочернего класса. public String name; // Переменная salary видна только в Employee. private double salary; // Имя переменной присваивается в конструкторе. public Employee (String empName){ name = empName; } // Переменной salary присваивается значение. public void setSalary(double empSal){ salary = empSal; } // Этот метод выводит на экран данные сотрудников. public void printEmp(){ System.out.println("имя: " + name); System.out.println("зарплата:" + salary); } public static void main(String args){ Employee empOne = new Employee("Олег"); empOne.setSalary(1000); empOne.printEmp(); } }

Программа будет будет производить следующий результат:

Имя: Олег зарплата: 1000.0

Переменные класса или статические переменные в Java

• Переменные класса, также известные в Java как статические переменные , которые объявляются со статическим ключевым слово в классе, но за пределами метода, конструктора или блока.
• Там будет только одна копия каждой статической переменной в классе, независимо от того, сколько объектов создано из него.
• Статические переменные или переменные класса в Java используются редко, кроме когда объявляются как константы. Константы - переменные, которые объявлены как public/private, final и static. Константы никогда не меняются от первоначального значения.
• В Java статические переменные создаются при запуске программы и уничтожаются, когда выполнение программы остановится.
• Видимость похожа на переменную экземпляра. Однако большинство статических переменных объявляются как public, поскольку они должны быть доступны для пользователей класса.
• Значения по умолчанию такое же, как и у переменных экземпляра. Для чисел по умолчанию равно 0, для данных типа Boolean - false; и для ссылок на объект - null. Значения могут быть присвоены при объявлении или в конструкторе. Кроме того, они могут быть присвоены в специальных блоках статического инициализатора.
• Статические переменные могут быть доступны посредством вызова с именем класса ClassName.VariableName .
• При объявлении переменных класса как public, static, final, имена находятся в верхнем регистре. Если статические переменные такими не являются, синтаксис такой же, как у переменных экземпляра и локальных.

Пример

import java.io.*; public class Employee{ // salary(зарплата) переменная private static private static double salary; // DEPARTMENT(отдел) - это константа public static final String DEPARTMENT = "Разработка "; public static void main(String args){ salary = 1000; System.out.println(DEPARTMENT+"средняя зарплата: "+salary); } }

Это будет производить следующий результат:

Разработка средняя зарплата: 1000

Примечание: для получения доступа из внешнего класса, константы должны быть доступны как Employee.DEPARTMENT.

В предыдущих материалах не раз упоминались модификаторы доступа. В следующем уроке мы подробно их рассмотрим.

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

В языке Java понятие беззнаковых чисел отсутствует. Все числовые типы этого языка - знаковые. Например, если значение переменной типа byte равно в шестнадцатиричном виде 0x80, то это число -1.

2.1.1.1. Целые типы

Отсутствие в Java беззнаковых чисел вдвое сокращает количество целых типов. В языке имеется 4 целых типа, занимающих 1, 2, 4 и 8 байтов в памяти. Для каждого типа - byte, short, int и long - есть свои естественные области применения.

Тип byte

Тип byte - это знаковый 8-битовый тип. Его диапазон - от -128 до 127. Он лучше всего подходит для хранения произвольного потока байтов, загружаемого из сети или из файла,

byte b;
byte с = 11;

Если речь не идет о манипуляциях с битами, использования типа byte, как правило, следует избегать. Для нормальных целых чисел, используемых в качестве счетчиков и в арифметических выражениях, гораздо лучше подходит тип int.

Тип short

Short - это знаковый 16-битовый тип. Его диапазон - от -32768 до 32767. Это, вероятно, наиболее редко используемый в Java тип, поскольку он определен как тип, в котором старший байт стоит первым,

short s;
short t= 129;
Тип int

Тип int служит для представления 32-битных целых чисел со знаком. Диапазон допустимых для этого типа значений - от -2147483648 до 2147483647. Чаще всего этот тип данных используется для хранения обычных целых чисел со значениями, достигающими двух миллиардов. Этот тип прекрасно подходит для использования при обработке массивов и для счетчиков. В ближайшие годы этот тип будет прекрасно соответствовать машинным словам не только 32-битовых процессоров, но и 64-битовых с поддержкой быстрой конвейеризации для выполнения 32-битного кода в режиме совместимости. Всякий раз, когда в одном выражении фигурируют переменные типов byte, short, int и целые литералы, тип всего выражения перед завершением вычислений приводится к int.

int j = 1000;
Тип long

Тип long предназначен для представления 64-битовых чисел со знаком. Его диапазон допустимых значений достаточно велик даже для таких задач, как подсчет числа атомов во вселенной,

long m;
long n = 123;

He надо отождествлять разрядность целочисленного типа с занимаемым им количеством памяти. Исполняющий код Java может использовать для ваших переменных то количество памяти, которое сочтет нужным, лишь бы только их поведение соответствовало поведению типов, заданных вами.

Таблица 2.1. Таблица разрядностей и допустимых диапазонов для различных типов целых чисел

		Разрядность	Диапазон
			-9, 223, 372,036, 854, 775, 808 ... 9, 223, 372, 036, 854, 775, 807
			-2, 147, 483, 648 .... 2, 147, 483, 647
			-32,768 .... 32, 767
			-128 ... 127

2.1.1.2. Числа с плавающей точкой

Числа с плавающей точкой, часто называемые в других языках вещественными числами, используются при вычислениях, в которых требуется использование дробной части. В Java реализован стандартный (IEEE-754) набор типов для чисел с плавающей точкой - float и double и операторов для работы с ними.

Таблица 2.2. Характеристики типов чисел с плавающей точкой

		Разрядность	Диапазон
			1.7e-308 .... 1 .7e+ 308
			3.4e-038 .... 3.4e+ 038

Тип float

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

float f;
float f2 = 3.14;
Тип double

В случае двойной точности, задаваемой с помощью ключевого слова double, для хранения значений используется 64 бита. Все трансцендентные математические функции, такие как sin, cos, sqrt, возвращают результат типа double,

double d;
double pi = 3.14159265358979323846;

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

1.1. Объявление переменных

Все переменные должны быть объявлены до первого их использования в программе. Основная форма объявления переменной такова:

тип идентификатор [ = значение] [, идентификатор [ = значение ]...];

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

Таблица 1.1. Объявление переменных различных типов

		Вид переменной
	int а, b, с;	Объявляет три целых переменных а, b, с
	int d = 3, е, f = 5;	Объявляет еще три целых переменных, инициализирует d и f
	byte z = 22;	Объявляет переменную z типа byte и инициализирует ее
	double pi = 3.14159;	Объявляет переменную pi типа double и инициализирует ее числом пи
	char x = "x";	Символьная переменная х получает значение "х"

Идентификатор – это наименование переменной. В качестве идентификатора может использоваться любая последовательность строчных и прописных букв, цифр и символов _ (подчеркивание) и $ (доллар). Идентификаторы не должны начинаться с цифры.

Значение - это любой литерал или выражение, результатом которого является значение того же (или совместимого с указанным в объявлении переменной) типа. В приведенном ниже примере создаются три переменные, соответствующие сторонам прямоугольного треугольника, а затем с помощью теоремы Пифагора вычисляется длина гипотенузы, в данном случае числа 5, величины гипотенузы классического прямоугольного треугольника со сторонами 3-4-5.

class Variables {
public static void main (String args ){
double a = 3;
double b = 4;
double c;
с = Math.sqrt (a* a + b* b);
System.out.println ("c = "+ c);
}

1.2. Область видимости переменной

Блоки составных операторов в Java отмечаются парой фигурных скобок {}. Переменные в Java начинают действовать с того места в программе, где они объявлены до конца содержащего их блока. Блоки могут быть вложены друг в друга, и у каждого может быть свой собственный набор локальных переменных.

Мы уже и использовали переменные в наших примерах, поскольку без них было бы очень затруднительно объяснить примитивные типы данных в Java, но не акцентировали на этом внимания, так как это не большая и не сложная тема. О константах в Java мы вообще пока не говорили. И вот настало время! Ну погнали!

Переменная — основной компонент хранения данных в Java-программе. Переменная определяется комбинацией идентификатора, типа и необязательного начального значения. Кроме того, все переменные имеют область определения, которая задает их видимость для других объектов и время существования .

В Java все переменные должны быть объявлены до их использования. Объявить переменную можно в любом месте программы. Основная форма объявления переменных выглядит следующим образом:

тип идентификатор [=значение][, идентификатор [=значение] ...] ;

• тип — это один из элементарных типов Java либо имя класса или интерфейса.
• идентификатор — это имя переменной

Переменной можно присвоить начальное значение (инициализировать ее), указывая знак равенства и значение. Следует помнить, что выражение инициализации должно возвращать значение того же (или совместимого) типа, который указан для переменной. Для объявления более одной переменной указанного типа можно использовать список с разделителями-запятыми.

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

a , b , c ; // объявление трех переменных типа int: a, b и c
int d = 3 , e , f = 5 ; // объявление еще трех переменных типа int с инициализацией d и f
byte z = 22 ; // инициализация переменной z
double pi = 3.14159 ; // объявление приблизительного значения переменной pi
char x = "x" ; // присваивание значения "x" переменной x

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

vacationDays ;
System . out . println ( vacationDays ) ; // ОШИБКА! Переменная не инициализирована

Как правильно именовать переменные мы уже обсуждали.

Динамическая инициализация переменных

Java допускает динамическую инициализацию переменных посредством любого выражения, допустимого в момент объявления переменной. Например:

a = 3.0 , b = 4.0 ;
// динамическая инициализация переменной c
double c = Math . sqrt ( a * a + b * b ) ;
System . out . println ( "Гипотенуза равна " + c ) ;

Область действия и время существования переменных

Это достаточно важный вопрос и его надо рассмотреть поподробнее. И для этого сперва надо рассмотреть использование блоков кода в Java.

Использование блоков кода

Java позволяет группировать один и более оператора в блоки кода, называемые также кодовыми блоками. Это выполняется путем помещения операторов в фигурные скобки. Сразу после создания блок кода становится логическим модулем, который можно использовать в тех же местах, что и отдельный оператор. Например, блок может служить в качестве цели для операторов if и for. Рассмотрим следующий оператор if:

( x < y ) { // начало блока
x = y;
y = 0 ;
} // конец блока

В этом примере, если x меньше y, программа выполнит оба оператора, расположенные внутри блока. Таким образом, оба оператора внутри блока образуют логический модуль, и выполнение одного оператора невозможно без одновременного выполнения и второго. Основная идея этого подхода состоит в том, что во всех случаях, когда требуется логически связать два или более оператора, это делается посредством создания блока.

Java допускает объявление переменных внутри любого блока. Блок начинается открывающей фигурной скобкой и завершается закрывающей фигурной скобкой. Блок задает область определения. Таким образом, приоткрытии каждого нового блока мы создаем новую область действия . Область действия задает то, какие объекты видимы другим частям программы. Она определяет также время существования этих объектов.

Основное правило, которое следует запомнить: переменные, объявленные внутри области действия, не видны (т.е. недоступны) коду, который находится за пределами этой области. Таким образом, объявление переменной внутри области действия ведет к ее локализации и защите от несанкционированного доступа и/или изменений.

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

Переменная y , определенная внутри своей области действия ограниченной фигурными скобками, доступна только в ней. За ее пределами переменная y уже не доступна, а переменная x доступна, и во области действия переменной y .

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

Это означает, что переменная утратит свое значение сразу по выходу из области действия.

Хотя блоки могут быть вложенными, во внутреннем блоке нельзя объявлять переменные с тем же именем, что и во внешней области .

Код приведенный на примере слева, выдаст ошибку компиляции.

Такие трюки возможные в C и C++ в Java не проходят.

Константы в Java

В Java для обозначения констант служит ключевое слово final . Ключевое слово final означает, что присвоить данной переменной какое-нибудь значение можно лишь один раз, после чего изменить его уже нельзя. Рекомендуется использовать для именования констант прописные буквы, хоть это и не является обязательным, но такой стиль способствует удобочитаемости кода. Пример объявления константы:

double CM_PER_INCH = 2.54 ;

Константу можно и не инициализировать при ее объявлении, но необходимо инициализировать до ее использования в каком-либо выражении, точно так же как и переменную, но сделать это можно только один раз. Причем это можно сделать и в условных операторах, то есть инициализировать значение константы в зависимости от каких либо условий. Компилятор проверит все возможные варианты, и если будет хоть один, где константа может быт не инициализирована, то он выдаст ошибку.