#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 соответсвенно.
Весь код будет доступен после подписки на проект!Задание к уроку
Создание переменной
Создайте целочисленную переменную с наименьшим диапазоном чисел. Укажите для нее значение равное восьми.
Объявляем переменные,
вычисляем выражения
Операторы +=, -=, *=,/=, ++, —
Каждая программа что-нибудь вычисляет. Это может быть все что угодно — координаты персонажа в игре, сумма расходов, количество букв в тексте и т.д. Для всех вычислений используются переменные и числовые выражения.
Пусть вам нужно что-то рассчитать. Например, вы хотите примерно оценить сумму своих расходов за год по разным категориям — на продукты, одежду и транспорт. Причем вы знаете, что одежду вы покупаете в год 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.
Самое главное мы уже освоили. Теперь время решать задачи. Ответьте на несколько вопросов, чтобы лучше усвоился новый материал:
Java Core для самых маленьких. Часть 3. Переменные
В предыдущей статье мы говорили о типах данных, а теперь поговорим о вытекающей из этого теме, о переменных.
Переменная — это поименованная область памяти, в которую мы можем сохранить данные, осуществлять доступ к этим данным или изменять их. Простыми словами, переменная в программировании, и в Java в том числе, является основной единицей хранения информации. В Java у переменной должен быть тип, имя и значение.
На скриншоте выше продемонстрирован пример создания переменных.
Тип — это тип данных переменной, которую необходимо создать. В примере используются примитивные типы данных, рассмотренные в предыдущей статье. Однако, переменная может быть не только примитивного типа. Переменная может являться экземпляром какого-либо класса. Изучать классы мы будем в следующих статьях.
Имя или Идентификатор — любую переменную нужно как-то обозвать. А даем мы имя переменной сразу после указания типа данных. Важно! Именем переменной может быть любая последовательность букв, цифр, но имя не может начинаться с цифры! При наименовании переменной так же учитывается регистр символов. abc и ABC будут разными именами. Еще можно встретить переменные, имя которых начинается с символа валюты доллара: $
Например: double $pi = 3.14; Такое можно увидеть в авто-генерируемых участках кода. Живые люди, насколько мне известно, так не пишут.
Давайте сразу научимся давать имена переменным правильно. Существует документ Java Code Conventions. В нем указаны правила к написанию кода на Java. Нужно это для того, что бы Java код в разных проектах был написан в едином стиле. Таким образом, новоприбывший на проект программист не будет отвлекаться на новый стиль кода, ведь он будет оформлен так же, как и на других проектах. Эти правила работают и при нейминге переменных.
Итак, переменные принято называть в lowerCamelCase стиле. Сейчас покажу как хорошо, а как плохо:
Как вы могли заметить, в примере, в имени переменной используется символ подчеркивания _ . На практике допускается использовать такой символ только для имен констант. Чем константа отличается от переменной? Переменная на то и переменная, что ее значение изменчиво и всегда можно присвоить другое:
Вот было значение 1998, а на следующей строке стало 2000. А вот с константой так не получится. Константа гарантирует, что ее значение не изменится на протяжении всего времени выполнения программы. Как создать константу? Очень просто:
Нужно всего лишь дописать ключевое слово final перед типом данных переменной. Для простоты понимания, мы как бы «финализируем» значение переменной и говорим, что это значение конечное.
Обратим внимание на имя константы. Когда мы даем имя константе, то должны делать это в стиле SCREAMING_SNAKE_CASE. Давайте исправим мой код:
В целом, вас никогда не погладят по головке за правильный нейминг в коде. Подразумевается, что это нечто естественное при написании кода. Как правила этикета у людей. А вот если вы будете называть ваши переменные и константы абы как, получите незамедлительного леща.
Инициализация переменных
У всех переменных из моих примеров уже было присвоено начальное значение. Процесс присвоения начального значения называется инициализацией переменной. И не обязательно инициализировать переменную во время ее объявления. Java позволяет сделать это и позже.
Во-первых, можно объявлять переменные через запятую (если они одинакового типа):
При этом, смотрите, мы можем некоторые из них инициализировать прямо во время объявления. А теперь инициализируем оставшиеся:
Для инициализации переменных типа char я использовал цепочку присваиваний. Да, и так тоже можно. Хотя используется очень редко.
Если мы попытаемся провести какую-то операция с переменной, у которой нет значения, то получим ошибку.
Оператор присваивания
Важно запомнить, что если вы где-то в коде Java, а также во многих других языках, увидите знак равенства = , вы должны понимать, что это не сравниваются два значения. Вы должны понимать что это оператор присваивания. Его задача: взять значение, которое стоит справа от него, и записать в память переменной, которая стоит слева от него, или другими словами присвоить. Важно, чтобы значения справа и слева были одного типа данных в противном случае получаем ошибку.
Литералы
Видели, в моих примерах выше, я писал значение переменной с типом long не просто 1998 а 1998L ? Сейчас расскажу, что это за L в конце.
В Java постоянные значения задаются литеральным представлением. Простым языком, при помощи определенных символов мы можем указывать тип данных. Вот например, при работе с целочисленными литералами нам не нужны никакие литералы. Мы просто пишем число 1998; и Java понимает, что это целочисленное значение.
Целочисленные литералы по умолчанию создаются в виде значения типа int , и это значение можно присваивать всем целочисленным типам данных без проблем, в случае, если это значение не выходит за пределы допустимых значений (в предыдущей статье мы говорили о диапазонах значений у разных типов данных). Но что делать, если мы хотим указать целое число, которое больше пределов числа типа int ? В этом случае есть возможность создать литерал типа long просто указав в конце символ L . Я мог и не писать 1998L , потому что число 1998 вполне помещается в диапазон значений типа данных int . А теперь, я вдруг захотел присвоить переменной типа long значение, скажем, в девять миллиардов. Число не маленькое и оно выходит за пределы максимального значения типа int .
Вот тут нам понадобится литерал типа long . При помощи символа L , в конце целочисленного значения, мы явно указывается, что это значение будет типа long , а следовательно и с большим диапазоном значений.
Так, что еще за символы подчеркивания в значении переменной? Это всего-навсего декор. С JDK 7 допустимо указывать знаки подчеркивания, для разбиения больших чисел на разряды, для удобства чтения.
В вышеописанных примерах были литералы для целочисленных десятичных значений. А еще мы можем присвоить целому числу литерал в виде восьмеричного значения. Для этого вам нужно добавить в самом начале значения 0. Но в таком случае, логично, что это значение не сможет содержать цифры 8 и 9, поскольку они выходят за пределы восьмеричной системы счисления.
Мало того, еще мы можем использовать литерал шестнадцатеричных значений. Такие значения обозначают с начальным 0x или 0X, а цифры в пределах от 10 до 15 заменяются символами ABCDEF английского алфавита.
С JDK 7 есть возможность указывать целочисленные литералы в двоичном виде. Для этого вначале значения нужно указать 0b или 0B и соответственно в значениях можно использовать только цифры 0 и 1. В реальности, вам навряд ли понадобятся литералы шестнадцатеричных, восьмеричного или двоичных значений. Однако, знать о них нужно.
Литералы дробных чисел
Литералы дробных чисел могут быть представлены в привычном для нас виде. Они состоят из целой и дробной части, которые разделены точкой. Например: 10.9; .
Но существует и экспоненциальная форма записи этих чисел в виде 2.34e12;
Где число после символа ‘e’ обозначает степень 10-ти. Простыми словами, мы записали 2 целых и 34 сотых умноженное на 10 в 12 степени.
По умолчанию литералы дробных чисел имеют тип double , если хотим создать литерал типа float , нужно указать символ f или F в конце значения. Как я уже сказал, по умолчанию, литерал будет типа double , однако мы все же можем указать это явно, дописав в конце значения символ d или D . Особого смысла это иметь, конечно же, не будет.
Как и в случае с целочисленными значениями, литералы с плавающей точкой поддерживают нижнее подчеркивание начиная с JDK 7.
Логические литералы
С логическими литералами все просто, они поддерживают только два логических значения true или false .
Символьные литералы
Для символьных литералов, которые присутствуют на вашей клавиатуре вы можете использовать одинарные кавычки, обернув ими необходимый вам символ введенный с клавиатуры.
Я не просто так обратил ваше внимание на символы с клавиатуры. Ведь существуют и такие символы, которых на клавиатуре нет, да и на символы они не похожи. Сейчас разберемся.
Как я уже говорил, тип char целочисленный и может хранить в себе символы кодировки Unicode. Unicode — это стандарт кодировки символов, который присваивает каждому символу код, в виде положительного целочисленного значения. Поэтому, тип char не может хранить отрицательные значения. А также, над типом char можно выполнять операции сложения и вычитания. Не представляю, зачем кому-то может понадобиться выполнять арифметические операции над типом char , но знайте, Java это позволяет. Мало того, коды символов английского алфавита (и многих других), расположены в порядке возрастания. Например, символу a соответсвует код 97, символу b — код 98. На основе этого можно сортировать символы по алфавиту.
А вот если символ нельзя ввести непосредственно с клавиатуры, то для ввода таких символов используют ряд управляющих последовательностей. Например, символ переноса строки ‘\n’. Существуют последовательности, которые существуют для ввода значений в восьмеричной и шестнадцатеричной форме. Например, мы захотели ввести букву tu катаканы смайлик: ツ. Берем и пишем:
В данной таблице вы можете посмотреть наиболее используемые последовательности символов:
Когда-то давно, я писал статью про экранирование символом. Настоятельно рекомендую прочитать, как дополнительный материал. Узнаете много интересного.
Строковый литерал
Можно заключить последовательность символов в двойные кавычки и получить так называемую строку.
Про строки будет отдельная статья, через одну если быть точным. Там нам будет о чем поговорить, а пока просто имейте ввиду что «» — это строковый литерал.
Динамическая инициализация
Пару слов о таком термине как динамическая инициализация. Ничего сложного, только звучит страшно.
Переменную можно инициализировать другой переменной. Также, допускается инициализация переменной результатом какого-то выражения.
Главное, чтобы тип данных выражения / инициализирующей переменной совпадал с типом данных целевой переменной.
Преобразование и приведение типов
Знаю, вы уже подустали, сделали массу перерывов и подходов. Обещаю, это последняя тема в этой статье.
Часто программисты сталкиваются с ситуацией, когда переменной одного типа приходится присваивать значение другого типа. Если оба типа данных совместимы, их преобразование будет выполнено автоматически. Для автоматического преобразования должно выполняться 2 условия:
Не так страшен черт, как его малюют. Все очень просто. Например, тип long достаточно велик чтобы поместить в себя тип int и прочие целочисленные типы данных которые меньше long .
На картинке выше, вы можете увидеть, какие типы данных вы можете преобразовать автоматически. Исходя из этого изображения, мы можем в переменную типа float поместить значение типа long . Звучит странно, давайте проверим:
Все работает. К сожалению, автоматическое преобразование не способно покрыть все потребности. Например если нужно тип int преобразовать в byte .
Чтобы выполнить преобразование двух несовместимых типов данных, нужно воспользоваться приведением типов. Это явное преобразование одного типа в другой. И выглядит это вот так:
Нужно понимать, что преобразование вы проводите на свой страх и риск. Вы должны быть уверенным в том, что преобразуемое значение помещается в диапазон целевого типа. В противном случае вы получите некорректные данные.
Подводим итоги
В этой статье мы поговорили о многих важных вещах. Узнали, как создавать переменные и константы в Java, и чем они отличаются. Узнали о способах инициализации переменных. Разобрались с тем, что такое литералы и какие они бывают. А так же выполнили преобразование и приведение типов данных.
Скажем спасибо Егору за предоставленный материал.
В следующей статье мы будем изучать массивы. Если переменная — это вагон, то поездом будет массив. В общем, будет опять многобукав и многомерные массивы. Всем спасибо за внимание. Учитесь старательно!
Как объявить переменную в Java? Инициализация переменной в Java. Константы в Java
В этой статье мы рассмотрим, что такое Java-переменные, что значит инициализация переменных, а также как объявлять константу и зачем вообще нужны переменные и константы в Java.
Переменная — это контейнер, содержащий какое-либо значение. При этом под переменным значением понимают строковое, числовое или логическое значение. Само определение говорит нам о том, что переменная может изменяться по ходу выполнения программы. А вот если у нас задана константа, то это значение меняться не может. Но давайте обо всём по порядку.
Виды переменных в Java
Существуют следующие типы переменных в Java: 1) примитивные (целые — byte, short, char, int, long; дробные или с плавающей точкой — float, double, логические — boolean); 2) ссылочные (создаются с применением конструкторов классов и нужны для доступа к объектам).
Так как Java является строго типизированным языком программирования, каждая переменная, объявляемая разработчиком, должна иметь связанный с переменным значением тип данных.
Как объявлять переменные в Java?
Перед использованием переменной нужно её объявить. Для объявления переменной в Java используют следующий синтаксис:
тип данных переменная [ = значение], [переменная [= значение], . ] ;Идём дальше: если нужно объявить больше чем одну переменную указанного типа, допускается применение списка с запятыми:
int a, b, c; // объявление трёх целых переменных a, b и cИнициализация переменной
Перед использованием переменной, нужно задать ей начальное значение. Этот процесс называется инициализация. Без инициализации мы можем получить ошибку во время выполнения программы, поэтому инициализация очень важна. Для инициализации переменной используют оператор присваивания. Слева указывается имя переменной, справа её значение.
Вот пример инициализации:
int x = 10; // объявление и инициализация переменной System.out.println(x); // 10Ниже посмотрим другие примеры инициализации и объявления переменных в Java:
int a = 10, b = 10; // Пример инициализации переменных double pi = 3.14159; // Объявление переменной pi и присвоение ей величины «пи» byte b = 22; // Инициализация переменной b типа byte char a = 'a'; // Переменной a типа char присваиваем значение 'a'Типы переменных в Java
Продолжаем наш небольшой урок для начинающих, посвящённый инициализации переменных в Java. Итак, можно выделить 3 типа переменных: - локальные; - статические (переменные класса); - переменные экземпляра.
Теперь давайте рассмотрим их подробнее.
Локальные переменные в 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 //так как инициализация отсутствует, программа не «может понять», к чему прибавлять цифру 7Пожалуй, об инициализации уже поговорили достаточно. Идём дальше.
Переменные экземпляра
Для начала рассмотрим основные свойства переменных экземпляра: - объявляются в классе, однако за пределами метода, блока, конструктора; - когда в стеке выделяется пространство для объекта, создаётся слот для всех значений переменных экземпляра; - в Java эти переменные создаются тогда, когда объект создаётся посредством ключевого слова «new», а удаляются, когда объект уничтожается; - переменные включают значения, ссылающиеся более чем на один метод, блок или конструктор; - переменные экземпляра можно объявить на уровне класса, а также до и после использования; - для переменных экземпляра могут быть предоставлены модификаторы доступа; - эти переменные в Java видимы для всех методов, блоков и конструкторов в классе. Рекомендуется делать их private. Также можно делать их видимыми для подклассов данных переменных посредством модификаторов доступа; - переменные имеют значения по умолчанию: 0 — для чисел, false — для логических значений, null — для ссылок на объект. Значения можно присвоить в конструкторе либо при объявлении; - переменные могут быть доступны при вызове имени переменной внутри класса. При этом в статических методах и разных классах они вызываются посредством полного имени — 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(2000); empOne.printEmp(); >>Результат работы нашей программы следующий:
имя: Сергей зарплата: 2000.0Рассмотрение переменных класса (статических переменных в Java) выходит за рамки нашей статьи. Давайте лучше поговорим о том, что такое константа и зачем нужны константы в Java.
Для чего используются константы?
Константы применяются в Java для хранения данных. Константа отличается от переменной. Главное отличие в том, что при использовании константы мы можем присвоить значение лишь один раз.
В остальном константа объявляется так же, как и переменная. Правда, в случае использования константы сначала идёт ключевое слово final:
final int LIMIT = 5; System.out.println(LIMIT); // 5 // LIMIT=57; // данный синтаксис возможен потому, что LIMIT — это константаКак правило, при записи имени константы применяют верхний регистр.
Константы позволяют задать переменные, которые больше не должны меняться. Допустим, у нас существует переменная для хранения числа «пи». При инициализации мы можем сразу же объявить, что она константа, ведь её значение постоянно.
На этом пока всё. Если хотите знать больше, чем объявление, инициализация и использование переменной, записывайтесь на курс «Разработчик Java». Здесь вы получите навыки разработки серверных приложений, овладеете низкоуровневыми и высокоуровневыми подходами к созданию многопоточных и многопроцессных приложений и много чего ещё.