Как объявить переменную в java

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

Например, чтобы создать переменную целочисленного типа, назовем ее myNumber и присвоить ей значение 10, можно написать следующий код:

int myNumber = 10;

int — это тип переменной,
myNumber — ее имя,
10 — начальное значение.

Если начальное значение не задано, то переменная будет иметь значение по умолчанию для данного типа данных.

8. Java – Типы переменных, объявление и инициализация

Переменная предоставляется нам именем хранения, чтобы нашей программой можно было манипулировать. Каждая переменная в 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. Java – Самоучитель для начинающих
2. Java – Обзор языка
3. Java – Установка и настройка
4. Java – Синтаксис
5. Java – Классы и объекты
6. Java – Конструкторы
7. Java – Типы данных и литералы
8. Java – Типы переменных
9. Java – Модификаторы
10. Java – Операторы
11. Java – Циклы и операторы цикла
11.1. Java – Цикл while
11.2. Java – Цикл for
11.3. Java – Улучшенный цикл for
11.4. Java – Цикл do..while
11.5. Java – Оператор break
11.6. Java – Оператор continue
12. Java – Операторы принятия решений
12.1. Java – Оператор if
12.2. Java – Оператор if..else
12.3. Java – Вложенный оператор if
12.4. Java – Оператор switch..case
12.5. Java – Условный оператор (? 🙂
13. Java – Числа
13.1. Java – Методы byteValue(), shortValue(), intValue(), longValue(), floatValue(), doubleValue()
13.2. Java – Метод compareTo()
13.3. Java – Метод equals()
13.4. Java – Метод valueOf()
13.5. Java – Метод toString()
13.6. Java – Метод parseInt()
13.7. Java – Метод Math.abs()
13.8. Java – Метод Math.ceil()
13.9. Java – Метод Math.floor()
13.10. Java – Метод Math.rint()
13.11. Java – Метод Math.round()
13.12. Java – Метод Math.min()
13.13. Java – Метод Math.max()
13.14. Java – Метод Math.exp()
13.15. Java – Метод Math.log()
13.16. Java – Метод Math.pow()
13.17. Java – Метод Math.sqrt()
13.18. Java – Метод Math.sin()
13.19. Java – Метод Math.cos()
13.20. Java – Метод Math.tan()
13.21. Java – Метод Math.asin()
13.22. Java – Метод Math.acos()
13.23. Java – Метод Math.atan()
13.24. Java – Метод Math.atan2()
13.25. Java – Метод Math.toDegrees()
13.26. Java – Метод Math.toRadians()
13.27. Java – Метод Math.random()
14. Java – Символы
14.1. Java – Метод Character.isLetter()
14.2. Java – Метод Character.isDigit()
14.3. Java – Метод Character.isWhitespace()
14.4. Java – Метод Character.isUpperCase()
14.5. Java – Метод Character.isLowerCase()
14.6. Java – Метод Character.toUpperCase()
14.7. Java – Метод Character.toLowerCase()
14.8. Java – Метод Character.toString()
15. Java – Строки
15.1. Java – Метод charAt()
15.2. Java – Метод compareTo()
15.3. Java – Метод compareToIgnoreCase()
15.4. Java – Метод concat()
15.5. Java – Метод contentEquals()
15.6. Java – Метод copyValueOf()
15.7. Java – Метод endsWith()
15.8. Java – Метод equals()
15.9. Java – Метод equalsIgnoreCase()
15.10. Java – Метод getBytes()
15.11. Java – Метод getChars()
15.12. Java – Метод hashCode()
15.13. Java – Метод indexOf()
15.14. Java – Метод intern()
15.15. Java – Метод lastIndexOf()
15.16. Java – Метод length()
15.17. Java – Метод matches()
15.18. Java – Метод regionMatches()
15.19. Java – Метод replace()
15.20. Java – Метод replaceAll()
15.21. Java – Метод replaceFirst()
15.22. Java – Метод split()
15.23. Java – Метод startsWith()
15.24. Java – Метод subSequence()
15.25. Java – Метод substring()
15.26. Java – Метод toCharArray()
15.27. Java – Метод toLowerCase()
15.28. Java – Метод toString()
15.29. Java – Метод toUpperCase()
15.30. Java – Метод trim()
15.31. Java – Метод valueOf()
15.32. Java – Классы StringBuilder и StringBuffer
15.32.1. Java – Метод append()
15.32.2. Java – Метод reverse()
15.32.3. Java – Метод delete()
15.32.4. Java – Метод insert()
15.32.5. Java – Метод replace()
16. Java – Массивы
17. Java – Дата и время
18. Java – Регулярные выражения
19. Java – Методы
20. Java – Потоки ввода/вывода, файлы и каталоги
20.1. Java – Класс ByteArrayInputStream
20.2. Java – Класс DataInputStream
20.3. Java – Класс ByteArrayOutputStream
20.4. Java – Класс DataOutputStream
20.5. Java – Класс File
20.6. Java – Класс FileReader
20.7. Java – Класс FileWriter
21. Java – Исключения
21.1. Java – Встроенные исключения
22. Java – Вложенные и внутренние классы
23. Java – Наследование
24. Java – Переопределение
25. Java – Полиморфизм
26. Java – Абстракция
27. Java – Инкапсуляция
28. Java – Интерфейсы
29. Java – Пакеты
30. Java – Структуры данных
30.1. Java – Интерфейс Enumeration
30.2. Java – Класс BitSet
30.3. Java – Класс Vector
30.4. Java – Класс Stack
30.5. Java – Класс Dictionary
30.6. Java – Класс Hashtable
30.7. Java – Класс Properties
31. Java – Коллекции
31.1. Java – Интерфейс Collection
31.2. Java – Интерфейс List
31.3. Java – Интерфейс Set
31.4. Java – Интерфейс SortedSet
31.5. Java – Интерфейс Map
31.6. Java – Интерфейс Map.Entry
31.7. Java – Интерфейс SortedMap
31.8. Java – Класс LinkedList
31.9. Java – Класс ArrayList
31.10. Java – Класс HashSet
31.11. Java – Класс LinkedHashSet
31.12. Java – Класс TreeSet
31.13. Java – Класс HashMap
31.14. Java – Класс TreeMap
31.15. Java – Класс WeakHashMap
31.16. Java – Класс LinkedHashMap
31.17. Java – Класс IdentityHashMap
31.18. Java – Алгоритмы Collection
31.19. Java – Iterator и ListIterator
31.20. Java – Comparator
32. Java – Дженерики
33. Java – Сериализация
34. Java – Сеть
34.1. Java – Обработка URL
35. Java – Отправка Email
36. Java – Многопоточность
36.1. Java – Синхронизация потоков
36.2. Java – Межпоточная связь
36.3. Java – Взаимная блокировка потоков
36.4. Java – Управление потоками
37. Java – Основы работы с апплетами
38. Java – Javadoc

Объявляем переменные,
вычисляем выражения
**Операторы +=, -=, *=,/=, ++, —**

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

Пусть вам нужно что-то рассчитать. Например, вы хотите примерно оценить сумму своих расходов за год по разным категориям — на продукты, одежду и транспорт. Причем вы знаете, что одежду вы покупаете в год 5 раз, продукты два раза в неделю, а транспортом пользуетесь каждый день, и знаете среднюю стоимость разовой покупки.

Это можно закодить так:

// Объявим по одной переменной для каждого вида расходов // Слева от равно пишем double - значит у нас будет дробное число // transp - имя переменной, мы его выбрали сами // Справа от равно - начальное значение double transp = 100; // на транспорт за один день тратим порядка 100 рублей double food = 500; // на еду за один заход в магазин в среднем 500 рублей double dress = 2000; // на одежду - 2000 //Начальное значение переменной result вычислим по выражению: double result = transp*365 + food*2*4*12 + dress*5; // То есть 365 раз за год потратились на транспорт, // еду покупали 2 раза в неделю, а недель 4 в месяце, а месяцев 12, // одежду купили 5 раз в год. // Теперь переменная result хранит сумму затрат за год - можно ее распечатать, // сравнить с другими переменными или использовать в дальнейших расчетах. // Удобно, что теперь мы можем менять значения исходных данных, // и смотреть, как это отразится на итоговом результате.

Определение. Переменная – это имя, которое обозначает некоторое число. Переменные могут получать начальное значение и потом менять его. У переменных есть тип – либо это целые числа ( int ), либо дробные ( double и float), либо символы ( char ). Переменные участвуют в любых выражениях наравне с обычными числами.

Объявить переменную — значит дать ей имя, указать, какого она типа, и указать начальное значение справа от знака равно. В коде это делается так:

int x = 10;

Это значит завести переменную с именем x , у которой тип – int , сокращенно от integer (по-английски «целое число»). Справа от знака равно ставится начальное значение переменной. Оно может быть просто равно заданному числу, например, 10, а может вычисляться через любое выражение.

В общем случае объявление переменной выглядит так:

тип имя = числовое выражение ;

Типы данных бывают такие – целое число int , дробное число double , символ char . Переменная — это имя, обозначающее заданное число. Вы можете это число по ходу программы менять. Как только вы объявили переменную, под неё выделяется место в оперативной памяти компьютера — ячейка. В ней записаны цифры данного числа в двоичной системе исчисления, где вместо привычных цифр 0, 1, 2, …, 9 есть только цифры 0 и 1.

Давайте поменяем значение переменной x вот так:

int x = 10; x = 200; //изменить значение икс - забыть 10, и запомнить 200 //слева int не указан, значит мы используем уже объявленную переменную

Разберем популярную ошибку — объявление одной и той же переменной дважды:

int x = 100; int x = 300; // ошибка - указав int, мы говорим "объявить новую x", но переменная x уже объявлена // Создадим другую переменную с именем y int y = 100; // Объявим ее еще раз с другим типом double y = 200.5; // ошибка - переменная y уже была раньше объявлена. // Теперь, когда мы указали новый тип, компилятор просто не может определиться, // что же имелось в виду, y - целое, или y - дробное. Вы можете получить ошибку // ambiguous name, то есть многозначное имя.

Посмотрим новый пример с несколькими переменными. Кстати я пишу, что делает очередная строчка в комментарии к ней. Комментарии не исполняются в программе, в них можно просто пояснять код. Комментарии на одну строчку в Java обозначаются // , а также внутри блока /* Можно писать всё что угодно */ — это комментарий на много строчек. Вы легко опознаете комментарии, когда увидите их в этом коде:

package javaapplication1; public class JavaApplication1 < public static void main(String[] args) < //вызовем функцию println System.out.println ("Щас будем вычислять!"); // Объявим переменную x целого типа, равную 10 int x = 10; // Объявим переменную y целого типа, равную 30 int y = 30; // Объявим переменную z, равную выражению: int z = x + y /2; // Распечатаем значение z – это будет 25 System.out.println (z); // Изменим z снова, пусть оно будет теперь x/2 z = x / 2; // Выведем на экран новое значение z – это будет 5 System.out.println (z); // Можно объявить несколько переменных в одной строчке int a = 10, b = 20; /* В принципе можно объявить переменную без начального значения, но Java ударит вас по рукам, если вы позже не присвоите ей значение. Лучше так не делать, потому что от переменных без начального значения пользы никакой, а навредить они могут сильно – если вдруг Java не заметит, что вы её используете, то вы получите непредсказуемое поведение программы, каждый раз разное – эту ошибку очень сложно отловить, иногда на её поиск уходят недели. */ int w; // Лучше не надо, поверьте.. w = 5; // Объявим переменную дробного типа double double some = 0.5; // Изменим значение переменной some на новое some = 1.5; // Сделаем some равной y some = y; // Объявим символ с равным коду буквы b char c = ‘b’; /* Здесь можно писать только одну букву или цифру в одинарных кавычках. Символы нельзя складывать, зато из них можно делать строки и тексты – мы займемся этим на следующих уроках*/ // Объявим дробное d, равное 2.5 double d = 2.5; /* Используем саму переменную, чтобы например, увеличить ее на 5: */ d = d + 5; // теперь d равно 7.5, старое значение забыто >/* В конце переменные, объявленные в main, удаляются - так происходит всегда по достижении конца блока фигурных скобок, внутри которого они были объявлены */ > /* По сути переменная – это число, записанное в ячейке памяти компьютера. Объявить переменную – значит назвать эту ячейку именем. Имя может быть одной буквой, а может быть и словом. Вы можете поменять число, сидящее в ячейке, или использовать его для вычисления других чисел. Это очень удобно, иначе вам пришлось бы указывать «вон то число», а потом «вот это число», чтобы сделать любые вычисления. Так писали программы в 80ых годах прошлого века – это было настолько неудобно, что элементарный калькулятор приходилось писать месяцами. Теперь, заводя переменные, мы пишем его за несколько минут. */

Привычные нам знаки арифметических действий +, — , * , / называются операторами, они служат для простых вычислений. Знак = тоже оператор и означает приравнять , то есть изменить старое значение переменной на новое. Но есть еще операторы +=, -= , *= , /= . Они читаются увеличить (уменьшить, умножить, поделить) переменную на значение справа. Рассмотрим пример ниже:

int x = 10; // Увеличим x на 10 x = x + 10; // Ту же фразу можно записать короче с оператором += x += 10;

То есть оператор += является просто сокращением и означает увеличить переменную на значение, стоящее справа. Аналогично, операторы -=, *=, /= вычитают, умножают, делят переменную на значение, стоящее справа, например:

double y = 12; double z = 3; // Поделим y на 3 и запишем новое значение в y y /= z; // Умножим на 4, затем на (z-2) y *= 4; y *= z-2; /* Все это допустимые операции, их удобно делать с операторами +=, -=, *=, /= */

Ещё операцию x += 1 тоже можно записать короче с помощью оператора инкремента ++ . То есть ++ означает «увеличить переменную на один». Аналогично — значит «уменьшить на 1». Посмотрим в коде:

int x = 10; x ++; // теперь x равен 11 x ++; // теперь x равен 12 x --; // теперь x снова 11

Можно писать x++ (постфиксный инкремент), а можно ++x (префиксный инкремент). Аналогично и с декрементом. Если эти операции стоят в коде отдельно от прочих, то оба варианта записи эквивалентны, они увеличивают x на 1. Если же x++ используется прямо в выражении, то разница есть . Поясним в коде:

int a = 10; // зададим a и b равным 10 int b = 10; // a++ означает в выражении использовать старое значение a, но в потом a увеличить int y = 5 + a++; // итого будет 5+10 // ++b означает уже в выражении увеличить b int z = 5 + ++b; // итого будет 5 + 11 System.out.println (a); System.out.println (b); System.out.println (y); System.out.println (z); /* Вывод программы: 11 11 15 16 */

Ещё поясняющий пример:

 // вариант с использованием x ++ // постфиксная запись, как бы "увеличить x после" выражения int x = 10; int y = 5 + x++; // будет эквивалентно следующему: int x = 10; int y = 5 + x; // в выражении старое значение x += 1; // уже после выражения мы увеличим x // а теперь то же самое с использование x-- // префиксная запись, как бы "увеличить перед" выражением int x = 10; int y = 5 + ++x; // будет эквивалентно следующему: int x = 10; x += 1; // перед выражением мы увеличим x int y = 5 + x; // в выражении новое увеличенное значение // Начинающим обучение можно лишний раз не думать об разнице x++, ++x // Просто не пишите их прямо в выражения, и считайте, что это просто "увеличить на 1" // Но если где-то встретите, то будете готовы :)

Более сложные выражения с участием скобок (. )

Скобки позволяют указать программе, что нужно в выражении вычислить раньше, а что потом. Выражения в скобках имеют абсолютный приоритет — сначала вычисляется то что в скобках, потом умножение и деление, потом уже сложение и вычитание. Разберёмся в приоритетах на примере:

double x = 10 + 5 * 2 - 3; // будет конечно 10+10-3, то есть 17 double y = (10 + 5) * 2 - 3; // теперь есть скобки , поэтому 15*2 - 3, то есть 27 double z = 100 / 4 * 2 + 5; // при равнозначном приоритете компилятор читает слева направо: // получится 100/4 - это 25, умножить на 2 - это 50, и добавить 5 - в итоге z=55 // Очень советую поэкспериментировать в коде с такими выражениями. // Усложняйте их постепенно, используйте старые значения переменной в новом выражении. // Несколько полезных примеров: z = z*z; // получается, возвести z в квадрат, // поскольку мы взяли старое значение, умножили его само на себя и записали в z. // Аналогично можно возвести в куб и вообще в любую степень: x = x*x*x ; // возвели x в куб. // Также можно получить обратную к исходной величину: x = 1 / x; // но помните, что если бы x был int, а не double, // то тут часто получался бы чистый ноль, // т.к. при делении целых дробные части отбрасываются. // Теперь пример на несколько скобок x = 10; x = (x + 10) / 2 - 5 * (x-2); // будет 20 / 2 - 5 * 8, то есть -30. // А также вложенные скобки: x = 10; x = (x + 5*(x-1) ) * 2 + 1; // будет (10 + 5 * 9) * 2 + 1 = 55 * 2 + 1 = 111.

Самое главное мы уже освоили. Теперь время решать задачи. Ответьте на несколько вопросов, чтобы лучше усвоился новый материал:

#4 – Переменные в Джава. Типы данных

Переменные являются, практически, главным аспектом любого языка программирования. В ходе урока вы изучите что такое переменные, зачем они нужны и как с ними можно работать. Дополнительно вы ознакомитесь с типами данных в языке Java.

Видеоурок

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

Переменные

Типы переменных в языке Java указываются перед названием переменной. От конкретного типа данных будет зависеть содержимое переменной. Если мы укажем что переменная с типом данных int (целые числа), то в неё мы не сможем записать строку или число с точкой.

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

float some_value = 2.95f; some_value = 6.9f; // Записали новое значение

Рассмотрим все типы данных для создания переменных.

Целые числа

byte — предназначен для хранения целых чисел. Диапазон чисел от -128 до 127, если число будет большим 127 или меньшим -128 , то выдастся ошибка;
short — предназначен для хранения целых чисел. Диапазон чисел от -32768 до 32767;
int — предназначен для хранения целых чисел. Диапазон чисел от -2147483648 до 2147483647;
long — предназначен для хранения целых чисел. Диапазон чисел от –9 223 372 036 854 775 808 до 9 223 372 036 854 775 807.

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

Числа с точкой

float — для создания чисел с плавающей точкой. Диапазон чисел от от -3.4*10 38 до 3.4*10 38 ;
double — для создания чисел с плавающей точкой. Диапазон чисел от от ±4.9*10 -324 до ±1.8*10 308 .

Прочие типы данных

bool — логический тип данных. Предназначен для записи истинного (true) или ложного (false) значения;
char — тип данных для работы с символами. Позволяет поместить в одинарных кавычках какой-либо символ;
String — тип данных для текста. В двойных кавычках можно сохранить одно или множество слов.

Для создания переменной необходимо указать тип данных и её название. Также можно сразу же добавить к ней значение:

int a = 0; // Добавление значения сразу byte c; // Создание переменной без значения short b, y = 342; // Создание нескольких переменных

Для вызова переменной вы можете обратиться к ней по имени. Чтобы записать данные в переменную с типом float или double необходимо после числа дописать букву f или d соответсвенно.

Весь код будет доступен после подписки на проект!

Задание к уроку

Создание переменной

Создайте целочисленную переменную с наименьшим диапазоном чисел. Укажите для нее значение равное восьми.

Как объявить переменную в java