Java как определить тип переменной. Примитивные типы Java

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

В языке 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

Variable Declaration
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:

Local Variables
Instance Variables
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:

Primitive Data Types
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

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

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 так:

тип_данных имя_переменной;

Здесь же при объявлении можно присвоить значение.

тип_данных имя_переменной = значение_переменной;

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

тип_данных имя_переменной1, имя_переменной2…;

Классификация по принадлежности

Выделяется четыре типа java переменных:

переменные экземпляра (instance variables);
переменные класса (class variables);
локальные переменные (local variables);
параметры (parameters).

Пусть у нас есть несколько объектов одного класса Automobile(). Помимо общих параметров у них есть уникальные, скажем, максимальная скорость maxSpeed(). Их можно инициировать в теле программы, а можно хранить в нестатических полях класса (объявленных без добавления слова static). Таким образом, каждый экземпляр будет обладать индивидуальным параметром, не зависящим от скоростей других объектов.

public class Automobile { public String name; private double maxSpeed ; public Automobile (String autoName ){ name = autoName; }}

Переменная класса, или статическая переменная java, напротив, объявляется исключительно с применением слова static. В данном случае её значение будет одинаковым для всех экземпляров. В случае того же автомобиля, введём параметр gearsNum – число передач. Для всех экземпляров оно будет равно 6.

Необязательный модификатор final позволяет присвоить значение переменной только один раз. За соблюдением этого следит компилятор.

public class Automobile { public String model ; private double maxSpeed ; public static final int gearsNum = 6 ; }

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

Крайний случай локальных переменных - это параметры. В частности, классический пример «Hello, World!»:

class HelloWorld { public static void main (String args ) { System . out. println("Hello World!" ); } }

Здесь сразу два параметра. Первая - собственно, «Hello, World!», вторая - аргумент строки args в main.

Классификация по видимости

На основании описанного выше, можно проследить ещё одно деление – по видимости переменных. Существует 4 группы:

Public. Данный модификатор переменных доступен всем классам и объектам программы. Объявляется при помощи ключевого слова public в начале строки.
Protected. Области видимости java переменных в этом случае ограничены текущим пакетом и подклассами. Объявляется аналогично - ключевым словом protected.
Package protected. Модификатор переменных, доступных только внутри пакета. Объявления не требуется, отсутствие ключевых слов указывает на package protected.
Private. Переменные, доступные исключительно внутри класса. В данном случае, определить тип переменной можно по ключевому слову private.

Несмотря на то, что приватные элементы доступны внутри класса, вопрос: «как обращаться к private java переменным?» всё же имеет ответ. Для того, чтобы иметь возможность извне поменять значение приватного параметра, достаточно внутри того же класса создать публичный метод. Например так:

class Drive { private int gears; public void setGears (int val ) { gears = val; } }

Таким образом, в случае необходимости вы легко сможете изменить значение private переменной.

Указатели - ещё один вариант глобальных переменных. Вспомните, для создания экземпляра объекта мы используем следующую запись:

класс_объекта имя_указателя = new класс_объекта;

Такие переменные называются ссылочными переменными.