Давайте сегодня по-быстрому разберемся с типами в Java. Все типы в Java делятся на две группы — это примитивные и ссылочные типы.

Здесь будем разбираться с примитивными типами.

Ну пожалуй самый примитивный тип — это логический тип данных. Он же boolean — самый простой тип данных. Переменная такого типа может хранить лишь два значения: true (истина) или false (ложь). С переменными такого типа можно проводить следующие опреации: «!» — отрицание (not), «&&» — логическое И (and), «||» — логическое ИЛИ (or), «^» — исключающе ИЛИ (xor). Таблицы истинности для этих операций можно .

Дальше целочисленные типы данных. К ним в Java относятся следующие типы: byte , short , int и long . Каждый из этих типов принимает разный диапазон значений, объединяет их только то, что все значения всегда целочисленные. Так для типа byte интеравал от?128 до 127, для типа short от?32768 до 32767, для типа int от?2147483648 до 2147483647 ну и для типа long интервал от?9.2·10 18 до 9.2·10 18 . C ними все просто вычитаем, складываем, делим, умножаем…

Ну и конечно есть типы данных с плавающей запятой, дробные типы. Это float и тип с двойной точностью double . float принимает значения в диапазоне приблизительно от?3.4·10 38 до 3.4·10 38 , а double в диапазоне от?1.8·10 308 до 1.8·10 308 . Помимо этого, для этих типов существуют особые значения +? — плюс бесконечность, -? — минус бесконечность и NaN — не число (например при делении на 0).

Итак, если мы хотим объявить переменную какого-то типа, мы должны указать сначала ее тип, а потом ее имя:

Int i; float f;

Так же сразу можно указать начальное значение:

Int i = 0; float f = 3.5;

В Java используется неявное преобразование типов. Что это такое? Ну например вы хотите сложить две переменные одна типа int а другая типа float. Тогда ваша переменная типа int будет преобразована к типу float и только после этого произойдет сложение. Соответственно и результат получится типа float. При этом меньший тип всегда преобразуется к бльшему, а целое к дробному. Ну например вот это будет работать:

Int a = 3; float b = 4.5, c; с = a + b;

а вот это нет:

Int a = 3, c; float b = 4.5; с = a + b;

Здесь переменная в которую записывается результат имеет тип int, а сам результат получится типа float. Конечно можно привести один тип к другому вручную. Делается это вот так:

Int a = 3, c; float b = 4.5; c = (int) (a + b);

здесь с помошью записи (int) мы приводим сумму a и b к типу int. Однако понятно, что в целочисленной переменной с не может храниться значение 7.5. При приведении дробных типов к целым дробная часть просто откидывается . Это может послужить причиной некотороых ошибок, поэтому об этом не стоит забывать.

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

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

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

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 понятие беззнаковых чисел отсутствует. Все числовые типы этого языка - знаковые. Например, если значение переменной типа 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;

What is a Variable?

A variable can be thought of as a container which holds value for you, during the life of a Java program. Every variable is assigned a data type which designates the type and quantity of value it can hold.

In order to use a variable in a program you to need to perform 2 steps

1. Variable Declaration
2. Variable Initialization

In this tutorial, you will learn-

Variable Declaration:

To declare a variable, you must specify the data type & give the variable a unique name.

Examples of other Valid Declarations are

Int a,b,c; float pi; double d; char a;

Variable Initialization:

To initialize a variable, you must assign it a valid value.

Example of other Valid Initializations are

Pi =3.14f; do =20.22d; a=’v’;

You can combine variable declaration and initialization.

Int a=2,b=4,c=6; float pi=3.14f; double do=20.22d; char a=’v’;

Types of variables

In Java, there are three types of variables:

1. Local Variables
2. Instance Variables
3. Static Variables

1) Local Variables

Local Variables are a variable that are declared inside the body of a method.

2) Instance Variables

Instance variables are defined without the STATIC keyword .They are defined Outside a method declaration. They are Object specific and are known as instance variables.

3) Static Variables

Static variables are initialized only once, at the start of the program execution. These variables should be initialized first, before the initialization of any instance variables.

Example: Types of Variables in Java

class Guru99 { int data = 99; //instance variable static int a = 1; //static variable void method() { int b = 90; //local variable } }

Data Types in Java

Data types classify the different values to be stored in the variable. In java, there are two types of data types:

1. Primitive Data Types
2. Non-primitive Data Types

Primitive Data Types

Primitive Data Types are predefined and available within the Java language. Primitive values do not share state with other primitive values.

There are 8 primitive types: byte, short, int, long, char, float, double, and boolean Integer data types

Byte (1 byte) short (2 bytes) int (4 bytes) long (8 bytes)

Floating Data Type

Float (4 bytes) double (8 bytes)

Textual Data Type

Char (2 bytes)

Boolean (1 byte) (true/false)

Data Type	Default Value	Default size
byte	0	1 byte
short	0	2 bytes
int	0	4 bytes
long	0L	8 bytes
float	0.0f	4 bytes
double	0.0d	8 bytes
boolean	false	1 bit
char	"\u0000"	2 bytes

Points to Remember:

• All numeric data types are signed(+/-).
• The size of data types remain the same on all platforms (standardized)
• char data type in Java is 2 bytes because it uses UNICODE character set. By virtue of it, Java supports internationalization. UNICODE is a character set which covers all known scripts and language in the world

Java Variable Type Conversion & Type Casting

A variable of one type can receive the value of another type. Here there are 2 cases -

Case 1) Variable of smaller capacity is be assigned to another variable of bigger capacity.

This process is Automatic, and non-explicit is known as Conversion

Case 2) Variable of larger capacity is be assigned to another variable of smaller capacity

In such cases, you have to explicitly specify the type cast operator. This process is known as Type Casting.

In case, you do not specify a type cast operator; the compiler gives an error. Since this rule is enforced by the compiler, it makes the programmer aware that the conversion he is about to do may cause some loss in data and prevents accidental losses.

Example: To Understand Type Casting

Step 1) Copy the following code into an editor.

Class Demo { public static void main(String args) { byte x; int a = 270; double b = 128.128; System.out.println("int converted to byte"); x = (byte) a; System.out.println("a and x " + a + " " + x); System.out.println("double converted to int"); a = (int) b; System.out.println("b and a " + b + " " + a); System.out.println("\ndouble converted to byte"); x = (byte)b; System.out.println("b and x " + b + " " + x); } }

Step 2) Save, Compile & Run the code.

Int converted to byte a and x 270 14 double converted to int b and a 128.128 128 double converted to byte b and x 128.128 -128