Главная › Интернет › Типы переменных в Java и какие когда стоит использовать. WDH: Java - Типы, значения и переменные

Типы переменных в Java и какие когда стоит использовать. WDH: Java - Типы, значения и переменные

За оператором объявления примитивной переменной может следовать оператор инициализации " = ", с помощью которого созданной переменной присваивается начальное значение.

1. Целые типы переменных

Целые типы различаются по размеру отведенной для них памяти. Характеристики целочисленных типов приведены в табл. 1.1. Табл. 1.1. Характеристики целочисленных типов Java

Как видно из приведенной таблицы, целые переменные, за исключением типа char , считаются в языке Java переменными со знаком. Целочисленные константы могут задаваться в программе одним из трех способов: в виде десятичных, шестнадцатеричных и восьмеричных значений. По умолчанию все числа интерпретируются как десятичные и относятся к типу int . Явно указать принадлежность к типу long можно, добавив в конце числа букву "l" или букву "L" . Шестнадцатеричное значение задается с помощью символов "0x" или "0X" , за которым значение числа (цифры 0-9 и буквы A-F или a-f), например: 0x7FFF . Число в восьмеричной записи должно начинаться с нуля, за которым следует одна или несколько восьмеричных цифр, например 077777 . Восьмеричные и шестнадцатеричные числа могут быть как положительными, так и отрицательными и изменяются в тех же диапазонах, что и числа в десятичном представлении (например, шестнадцатеричные числа типа byte имеют максимальное значение 0x7F и минимальное значение – 0x80 , а восьмеричные – соответственно 177 и – 200) Примеры объявления целых переменных: int x = 0 ; long i, j, k; byte a1 = 0xF1 , a2 = 0x07 ; short r1 = 017 ; Символы в Java определяются с помощью ключевого слова char и реализованы с использованием стандарта Unicode. Можно задать константу-символ в программе или как обычный символ. Символьное значение должны быть заключено в пару одиночных апострофов, например: char symbol= "f" ; Другой способ записи символов: пара символов "\u" , за которой следует четырехзначное шестнадцатеричное число (в диапазоне от 0000 до FFFF), представляющее собой код символа в Unicode, например: char symbol = "\u0042" ; Некоторые символы, отсутствующие на клавиатуре, можно задавать с помощью так называемых escape-последовательностей, содержащих символ " \ ", за которым следует буквенный символ, идентифицирующий escape-последовательность, как показано в табл. 1.2. Табл. 1.2. Escape-последовательности, используемые в языке Java

Что еще почитать:

2. Вещественные типы переменных

Язык Java поддерживает числа и переменные с плавающей точкой обычной и двойной разрядности – типы float и double . Для чисел с плавающей точкой нужно указывает целую и дробную часть, разделенные точкой, например 4.6 или 7.0 . Для больших чисел можно использовать экспоненциальную форму записи (для отделения мантиссы от порядка используется символ "e" или символ "E"), например, число -3,58×107 записывается как –3.58E7 , а число 73,675×10-15 – как 73.675e-15 . Характеристики вещественных типов Java представлены в табл. 2.1. Табл. 2.1. Характеристики вещественных типов Java

Переменные с плавающей точкой могут хранить не только численные значения, но и любой из особо определенных флагов (состоянии): отрицательная бесконечность, отрицательный нуль, положительная бесконечность, положительный нуль и «отсутствие числа» (not-a-number, NaN). Все константы с плавающей точкой подразумеваются принадлежащими к типу double . Чтобы задать число типа float , необходимо добавить в его конец символ "f" или символ "F" . Примеры объявления переменных с плавающей точкой: float x1 = 3.5f , x2 = 3.7E6f , x3 = - 1.8E-7f ; double z = 1.0 ;

3. Булевский тип переменных

Переменные булевского типа (логические переменные) могут принимать одно из двух значений: «истина» или «ложь» и используются в языках программирования в операциях отношения (сравнения) и логических операциях. Так, результатом сравнения 5 > 3 будет «истина», а результатом сравнения 8 < 1 будет «ложь». В отличие от C, где результату «ложь» сопоставлено целое значение типа int , равное 0, а результату «истина» – ненулевое значение типа int , и, соответственно, результатам сравнения присваивается целое значение (обычно 0 или 1), в Java для булевских переменных введен свой, отдельный тип данных. Переменные булевского типа в Java задаются с помощью ключевого слова boolean и могут иметь лишь одно из двух значений: true или false , например boolean switch = true ; Ссылка на перво

Переменная предоставляется нам именем хранения, чтобы нашей программой можно было манипулировать. Каждая переменная в 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?

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

В 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 должно иметь тип , определенный уже на этапе компиляции. Каждый тип имеет определенный диапазон значений и определяет набор применимых к нему операций и их смысл. Строгая типизация помогает обнаруживать ошибки в программе на этапе компиляции.

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

Объект в Java это или динамически созданный экземпляр класса, или динамический созданный массив. Значениями ссылочного типа являются ссылки на объекты. Все объекты, включая массивы, наследуют методы класса Object . Строки представляются объектами класса String .

Переменная это именованное хранилище данных определенного типа. Точнее говоря:

Переменная примитивного типа всегда содержит значение именно этого типа.
Переменная типа класс может содержать либо значение null (нулевую ссылку), либо ссылку на объект данного класса или его наследника.
Переменная типа интерфейс может содержать либо нулевую ссылку, либо ссылку на объект любого класса, реализующий данный интерфейс.
Переменная типа " array of T ", где T примитивный тип, может содержать либо нулевую ссылку, либо ссылку на объект типа " array of T ".
Переменная типа " array of T ", где T ссылочный тип, может содержать либо нулевую ссылку, либо ссылку на массив, состоящий из данных, совместимых с T по присваиванию.
Переменная типа Object может содержать либо нулевую ссылку, либо ссылку на любой объект.

5.3.2. Примитивные типы

5.3.2.1. Тип boolean

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

Пример декларации логической переменной:

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

5.3.3.2. Класс Object

Стандартный класс Object является предком всех остальных классов Java, которые наследуют его методы. Подробно эти методы описаны в гл. 5.14 .

5.3.3.3. Класс String

Экземплярами класса String являются текстовые строки, т. е. цепочки символов Unicode. Объект класса String имеет постоянное (неизменяемое) значение. Строковые константы являются ссылками на экземпляры класса String .

Оператор конкатенации строк неявно создает новый объект класса String .

5.3.4. Переменные

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

5.3.4.1. Виды переменных

В Java существуют семь разновидностей переменных:

Переменная класса это статическое поле данных в декларации класса или любое поле данных в декларации интерфейса. Переменная класса создается при загрузке ее класса или интерфейса; сразу после создания ей присваивается значение по умолчанию. Переменная класса уничтожается, когда ее класс или интерфейс выгружается (после завершения его финализации).
Переменная реализации это поле данных в декларации класса, которое не является статическим. Такая переменная создается и получает значение по умолчанию при создании экземпляра данного класса или класса, который является его потомком. Переменная реализации уничтожается, когда соответствующий экземпляр класса удаляется процедурой сборки мусора (после завершения его финализации).
Элементы массива это неименованные переменные, которые создаются и получают значение по умолчанию при создании массива. Эти переменные уничтожаются, когда массив удаляется процедурой сборки мусора.
Параметры конструктора это имена значений аргументов, передаваемых конструктору. Для каждого параметра в декларации конструктора создается новая переменная каждый раз, когда вызывается данный конструктор (явно или неявно). Этой переменной присваивается фактическое значение аргумента, переданное конструктору при вызове. Переменная уничтожается после завершения выполнения тела конструктора.
Параметры метода это имена значений аргументов, передаваемых методу. Для каждого параметра в декларации метода создается новая переменная каждый раз, когда вызывается данный метод. Этой переменной присваивается фактическое значение аргумента, переданное методу при вызове. Переменная уничтожается после завершения выполнения тела метода.
Параметр обработчика исключений создается всякий раз, когда выполняется часть catch оператора try . Его значением становится объект, ассоциированный с возникшим исключением. Переменная уничтожается после завершения выполнения блока catch .
Локальные переменные . Каждый раз, когда в ходе выполнения программы управление передается новому блоку или оператору for , для каждой декларации переменной внутри этого блока или оператора создается соответствующая локальная переменная. Если декларация содержит начальное значение переменной, то ей присваивается это значение. Локальная переменная уничтожается после завершения выполнения блока или оператора, в котором она объявлена.

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

Class Point { static int numPoints; // numPoints - переменная класса int x, y; // x и y - переменные реализации int w = new int; // w - массив целых чисел, w - элемент массива int setX(int x) { // x - параметр метода int oldx = this.x; // oldx - локальная переменная this.x = x; return oldx; } }

5.3.4.2. Начальные значения переменных

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

Каждой переменной класса, переменной реализации и каждому элементу массива при создании присваивается значение по умолчанию следующим образом:

переменные типов byte , short , int , long получают значение 0 соответствующего типа;
переменные типов float и double получают значение +0 соответствующего типа;
переменные типа char получают значение "\u0000";
переменные типа boolean получают значение false ;
переменные ссылочных типов получают значение null ;

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

Переменная - это основной элемент хранения информации в 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 начинают действовать с того места в программе, где они объявлены до конца содержащего их блока. Блоки могут быть вложены друг в друга, и у каждого может быть свой собственный набор локальных переменных.