- Основы
- Ключевые слова
- Переменные
- Оператор присваивания
- Комментарии
- Backdoor!
- Стиль оформления кода
- Операторы
- Оператор деления по модулю
- Приоритет
- Укороченная форма записи
- Автоувеличение и автоуменьшение на единицу
- По ссылке или по значению
- Android studio типы переменных
- Простые числовые типы
- Целочисленные типы
- Тип byte
- Тип short
- Тип int
- Сказка про тип int
- Деление целочисленных чисел
- Как сконвертировать строку или CharSequence в int?
- Как сконвертировать число в строку?
- Добавить ведущие нули
- Тип long
- Типы с плавающей точкой
- Тип float
- Тип double
- Конвертация строки в double
- Конвертация double в строку
- Символы (тип char)
- Класс Character
- Булевы значения
- Класс Boolean
- Приведение типов
Основы
Ключевые слова
Как и в любом языке программирования, в языке Java резервируются определенные слова, которые компилятор распознает как особые. Их нельзя использовать для именования конструкций Java: переменных, методов и т.д. Список ключевых слов не слишком велик:
abstract | assert | boolean | break | byte |
case | catch | char | class | const |
continue | default | do | double | else |
enum | extends | final | finally | float |
for | goto | if | implements | import |
instanceof | int | interface | long | native |
new | package | private | protected | public |
return | short | static | strictfp | super |
switch | synchronized | this | throw | throws |
transient | try | void | volatile | while |
Формально слова true, false и null не входят в число ключевых слов, но их тоже нельзя использовать в качестве имён переменных. Обратите внимание, что Android Studio выделяет ключевые слова в редакторе кода особым цветом (синтаксическая подсветка).
Переменные
Переменные используются для хранения данных. Переменные сначала должны быть объявлены, и только после этого ими можно пользоваться.
Как следует из названия, переменные могут меняться (точнее их значения). Проведём аналогию с кошачьим приютом. Котов привозят в приют, потом добрые люди забирают котов из него. Получается, что коты постоянно меняются, а приют остаётся.
Переменные могут быть двух видов
- примитивные типы: int, float, double, char и другие, которые представляют собой числа, символы
- объекты, которые представляют классы
Список переменных примитивных типов рассматривается в следующей статье.
Переменной можно присвоить начальное значение (инициализировать) через знак равенства и указанием значения. Указываемое значение должно подходить типу, который вы указали для переменной. Для объявления нескольких переменных одного типа можно использовать запятые:
Также возможна динамическая инициализация. Вам нужно только проследить, чтобы вычисляемое выражение соответствовало переменной.
В некоторых случаях нужно, чтобы переменная не менялась, в этом случае переменная называется константой и имеет ключевое слово final.
Переменные имеют свою область видимости. Она может быть доступна только внутри метода, цикла, класса. Подобная защита уменьшает риск ошибок от несанкционированного доступа или изменений от чужого кода. Также следует помнить, что внутри блока переменные можно объявить в любом месте, но они становятся допустимыми только после объявления. Если ситуация будет обратной, то конструкция будет бессмысленной и вам не разрешат так делать:
Переменные создаются при входе в их область видимости и уничтожаются при выходе из неё. Иными словами, переменная утратит своё значение сразу после выхода из области видимости. Поэтому, переменные, которые объявлены внутри метода, не будут хранить свои значения между обращениями к этому методу.
Если объявление переменной содержит инициализацию, то инициализация будет повторяться при каждом вхождении в блок, в котором она объявлена. Допустим, у нас есть блок:
При каждом вхождении в цикл переменной присваивается снова и снова значение 42. И хотя потом переменной присваивается значение 54, оно теряется при повторном вхождении в блок.
Блоки бывают вложенными, но тем не менее во внутреннем блоке нельзя объявлять переменные с тем же именем, что и во внешней области:
Оператор присваивания
Оператором присваивания является одиночный знак равенства (=):
Тип переменная должен соответствовать типу выражение. Оператор присваивания можно использовать в виде цепочки присваивания:
Оператор присваивания берёт значение правого выражения. Поэтому выражение z = 9 будет равно 9, после чего оно присваивается переменной y, а затем — переменной x.
Помните, что в сравнении используется другой оператор ==, а не оператор присваивания.
Комментарии
В Java используются три вида комментариев. Многострочные комментарии начинаются с символов /* и заканчиваются символами */. Однострочные комментарии начинаются с комбинации символов //. Причем, однострочный комментарий можно использовать не только на отдельной строке, но и после оператора.
Начинающим программистам необходимо писать комментариев как можно больше, так как, вернувшись к своему коду через месяц-другой, вы с трудом вспомните, что вы тут нашкодили накодили.
Существует ещё третий тип комментариев для создания самодокументирующего кода (комментарий документации). Но это отдельная тема для разговора.
В студии создание и управление комментариями можно упростить через меню Code. Там вы найдёте такие команды как Comment With Line Comment, Comment With Block Comment. Попробуйте самостоятельно разобраться с ними.
Backdoor!
С помощью комментария злобные программисты могут внедрить закладку в разрабатываемый софт. Если в комментариях программы использовать Unicode для переноса строки и после нее написать свой код, то IDE (Android Studio) будет отображать это как комментарий, но код будет выполняться.
На первый взгляд, код не должен выполняться. Но это не так. Можете проверить.
\u000a — это Unicode-символ переноса строки (он же \n). Сначала производится декодирование, а потом уже разбор самого кода. Получается, что сначала произойдёт перенос, а потом будет напечатан рабочий код. Следующий пример тоже рабочий.
Стиль оформления кода
Существует негласные правила оформления стиля при написании кода. Старайтесь их придерживаться. Также запоминайте оформление кода в документации и справочниках. Например, принято записывать имена классов с большой буквы (class JavaQuickCourseActivity). Если имя состоит из нескольких слов, то каждое слово в имени также начинается с большой буквы. Использовать символы подчеркивания или тире нежелательно (Java_Quick_Course_Activity или Java-Quick-Course-Activity).
Для методов и переменных используется такой же формат, только первый символ записывается с маленькой буквы, например, resultButton.
Константы принято писать только большими буквами — IDD_LIST_NAMES. В этом случае одного взгляда достаточно, чтобы сразу определить, что перед вами константа.
На первых порах вам этого достаточно.
Операторы
Как и везде, в Java есть операторы сложения (+), вычитания (-), умножения (*), деления (/), которые применимы к числам.
Оператор | Пример использования | Описание |
---|---|---|
+ | a + b | Сложение а и b (также унарный плюс) |
+ | +a | Преобразование a в переменную типа int, если это переменная типа byte, short или char |
— | a – b | Вычитание b из а (также унарный минус) |
— | -a | Арифметическая инверсия а |
* | a * b | Умножение а на b |
/ | a / b | Деление a на b |
% | a % b | Вычисление остатка от деления а на b (деление по модулю) |
++ | a++ | Приращение а на 1 с предварительным вычислением значения а (инкремент) |
++ | ++a | Приращение а на 1 с последующим вычислением значения а |
— | a— | Уменьшение а на 1 с предварительным вычислением значения а (декремент) |
— | —a | Уменьшение а на 1 с последующим вычислением значения а |
+= | a += b | Краткая форма записи a = a + b (сложение с присваиванием) |
-= | a -= b | Краткая форма записи a = a – b (вычитание с присваиванием) |
*= | a *= b | Краткая форма записи a = a * b (умножение с присваиванием) |
/= | a /= b | Краткая форма записи a = a / b (деление с присваиванием) |
%= | a %= b | Краткая форма записи a = a % b (деление по модулю с присваиванием) |
Операнды арифметических операторов должны иметь числовой тип. Нельзя использовать их к логическим типам. Можно применять к типам char, который по сути можно представлять как тип int.
Для строк можно использовать только операции + и +=. Умножать, вычитать и делить слова нельзя. Обратите внимание, что при сложении слов «мышь»+»мышь» получается не «мыши», как предположил мой кот Рыжик, а «мышьмышь». На самом деле символ + при работе со строками называется не сложением, а конкатенацией.
Оператор деления по модулю
Существует оператор, вычисляющий остаток от деления нацело (%). Чтобы запомнить данный знак, обратите внимание на наклонную черту, как в обычном делении, которую окружают два нолика. Деление нацело обрезает, а не округляет результат.
Если 42 разделить по модулю на 10, то получим значение 2, а если 42.56 разделить по модулю на 10, то получим 2.5600000000000023:
Деление по модулю очень удобно использовать для разбивки числа на части. Предположим вам надо получить последние две цифры 2013 года. Вот как можно это сделать:
Вот и другой пример. Предположим, у вас есть фильм «Кот в сапогах», продолжительность которого равна 135 минутам. Чтобы разбить это число на часы и минуты, нужно применить такой код:
В результате получим ответ: Кот в сапогах идёт 2 часа 15 минут.
Обратите внимание, что переменная minutes всегда будет содержать числа в диапазоне от 0 до 59.
Стоит запомнить одну особенность. При делении большого числа на меньшее, например (5 % 4), понятно, что остаток будет 1. При делении по модулю меньших чисел 0, 1, 2, 3 на число 4 получатся те же значения 0, 1, 2, 3.
Напоследок, остаётся сказать, что делить на 0 нельзя. У вас будет выводиться сообщение об ошибке либо на этапе компиляции, либо во время работы программы.
В задачнике есть упражнения с применением данного оператора: 1, 2
Приоритет
Если вы не прогуливали уроки математики, то знаете, что в сложных выражениях скобки позволяют определить порядок вычислений. Например, в выражении 2 + 3 * 4 сначала идет умножение, а потом сложение. Расставив скобки, мы можем сначала сложить два числа, а потом умножить:
Кстати, использование скобок не влияет на производительность программы. Поэтому можете не стесняться и расставлять их побольше.
Укороченная форма записи
В Java также можно использовать укороченную форму записи, чтобы одновременно произвести операцию и присвоение. Для укороченной записи используется оператор с последующим знаком равенства. Например, чтобы прибавить число 7 к переменной x и присвоить результат этой же переменной, используйте команду x += 7. Это справедливо и для других операторов:
Укороченная форма записи не только сокращает объём и время написания кода, но и работает более эффективно (хотя доказательств не знаю).
Автоувеличение и автоуменьшение на единицу
Очень часто вам придется увеличивать или уменьшать значение переменной на единицу. Поэтому существует специальные операторы увеличения (инкремента) и уменьшения (декремента). Для инкремента используются два плюса (++), а для декремента два минуса (—).
Данные операторы существуют в двух версиях — префиксной и постфиксной. Префиксный инкремент или декремент значит, что ++ или — записываются перед переменной или выражением.
В этом случае сначала выполняется операция, а затем выдается результат.
При постфиксном инкременте или декременте оператор записывается после переменной или выражения:
Здесь сначала выдается значение, и лишь затем выполняется операция.
Например, мы хотим ежегодно увеличивать возраст кота в анкете:
Данный код аналогичен более длинному варианту:
В простых выражениях особой разницы в постфиксной и префиксной формами нет, но в сложных выражениях может играть существенную роль. Поэтому не рекомендую использовать этот способ в выражениях, чтобы не запутаться самому. Пишите код проще.
Инкремент и декремент применяется только к значениям переменных, к числу применять этот способ нельзя.
По ссылке или по значению
У нас есть класс Cat
Попробуем, используя этот класс, передать объект Cat в метод и посмотреть, что получится:
Вызовем созданные методы и увидим, как работают объекты:
Источник
Android studio типы переменных
Статья проплачена кошками — всемирно известными производителями котят.
Если статья вам понравилась, то можете поддержать проект.
Вселенная Java состоит из трёх субстанций: примитивы, объекты и коты. Про последних в документации ничего не говорится, поэтому их рассматривать не будем, но они существуют!
Примитивные типы Java не являются объектами. К ним относятся:
- boolean — булев тип, может иметь значения true или false
- byte — 8-разрядное целое число
- short — 16-разрядное целое число
- int — 32-разрядное целое число
- long — 64-разрядное целое число
- char — 16-разрядное беззнаковое целое, представляющее собой символ UTF-16 (буквы и цифры)
- float — 32-разрядное число в формате IEEE 754 с плавающей точкой
- double — 64-разрядное число в формате IEEE 754 с плавающей точкой
Примитивный в данном случае не оскорбление, а просто даёт понять, что речь идёт о простом типе, который не умеет прыгать, спать или мяукать. Да что он вообще умеет? Ой, всё.
Простые числовые типы
Тип | Разрядность | MIN | MAX |
---|---|---|---|
byte | 8 бит | -128 | 127 |
short | 16 бит | -32768 | 32767 |
int | 32 бит | -2147483648 | 2147483647 |
long | 64 бит | -9223372036854775808 | 9223372036854775807 |
float | 32 бит | -3.4E+38 | 3.4E+38 |
double | 64 бит | -1.7E+308 | 1.7E+308 |
Целочисленные типы
Java определяет четыре целочисленных типа: byte, short, int, long. Они могут быть положительными и отрицательными (Java не поддерживает только положительные значения без знака, как некоторые языки программирования).
Тип byte
Наименьший по размеру целочисленный тип — byte. Это 8-битовый тип с диапазоном допустимых значений от -128 до 127. Переменные типа byte часто используются при работе с потоком данных из сети или файла, а также при работе с необработанными двоичными данными или в массивах для экономии памяти.
Объявить переменную типа byte можно следующим образом:
В арифметических выражениях с переменными типа byte вычисления выполняются как с типом int, т.е. с помощью 32-битовой арифметики, а полученный результат будет 32-битовым. Смотри пример с short.
Строку с числом перевести в данный тип можно через метод parseByte(String):
Класс Byte является оболочкой для данного типа. Без необходимости не используйте в Android класс Byte.
Слово «байт» (byte) возникло в компании IBM примерно в 1956 году. Оно произошло от слова bite («кусок»), но его было решено писать через букву y, чтобы не путать со словом «bit» («бит»). В течение некоторого времени слово «байт» обозначало просто число битов в конкретном потоке данных. Однако в середине 1960-х, в связи с разработкой семейства компьютеров System/360 в компании IBM, это слово стало обозначать группу из восьми бит.
Любопытно, что bite имеет также значение «укус» (сущ.) или «укусить» (глагол). Таким образом это наш родной «Кусь!»
Тип short
Тип short — 16-битовый тип в диапазоне от -32768 до 32767. Используется очень редко.
В арифметических выражениях с переменными типа short вычисления выполняются как с типом int, т.е. с помощью 32-битовой арифметики, а полученный результат будет 32-битовым. Например, такой код не пройдёт.
Java будет ругаться на последнюю строчку, так как итоговый результат не может быть short. Как вариант, вам нужно преобразовать результат снова в 16-битовое число.
Явно перевести строку с числом в тип short можно через метод parseShort(String):
Класс Short является оболочкой для данного типа. Без необходимости не используйте в Android класс Short.
Тип int
Целые числа, представленные типом int, являются самым распространённым типом в программе, с которым вы будете работать. Поэтому нужно хорошенько изучить его и узнать его достоинства и ограничения. Это 32-битовый тип, имеющий диапазон допустимых значений от -2147483648 до 2147483647 (около двух миллиардов). Этого числа вполне достаточно, чтобы посчитать всех котов на свете. Часто используется в циклах, индексировании массивов, хотя может показаться, что для небольших операций в цикле и массивах проще использовать short или byte. Нужно запомнить, что тип int эффективен в этих случаях из-за особенностей структуры вычислительных процессоров. Просто примите на веру.
Сказка про тип int
Зададим себе вопрос, насколько большим может быть целое число типа int?
Напишем простую программу, где будем умножать переменную саму на себя. Для начала присвоим ей значение 2, а дальше строчка за строчкой будем выводить результат. Результаты будем отдавать коту учёному LogCat. Весь код поместим в обработчик события щелчка на кнопке нашей учебной программы, а первую строчку поместим выше её.
Запустите программу и нажмите кнопку. В нижней части студии откройте панель Android Monitor и в ней вкладку logcat. Настройте его фильтр, чтобы отображались только наши сообщения. В результате мы получим такую картину:
Что за бред, скажете вы. Когда мы умножаем 65536 на себя, то получаем 0 (Только не говорите об этом учительнице по математике). А потом, естественно, программа умножает 0 на 0 и продолжает выводить результаты.
Вы ещё больше удивитесь, если в качестве начального значения возьмёте число 3. На этот раз вы сможете получить даже отрицательные значения.
Проверьте самостоятельно. Если вы и это попытаетесь доказать учительнице, то исключение из учебного заведения вам гарантировано.
Деление целочисленных чисел
Запомните, что при делении целочисленных чисел остаток отбрасывается. Поэтому следующие примеры вернут один и тот же результат. Бедная учительница, её увезут в психушку.
На ноль делить нельзя, увидите ошибку.
Если нужен узнать остаток от деления, то используйте оператор % (оператор деления по модулю).
Класс Integer является оболочкой для данного типа. Без необходимости не используйте в Android класс Integer. Для сравнения: тип int занимает 4 байт памяти, а Integer — 16 байт.
Также есть специальный класс BigInteger для проведения арифметических действий повышенной точности (финансовые расчёты).
В Java 7 можно использовать знак подчёркивания для удобства. Например, так:
Компилятор не обращает внимания на эти знаки, а человеку проще понять, что ему предлагают миллион или миллиард. В Android относительно недавно появилась полноценная поддержка Java 7 и вам в настройках нужно указать новую версию компилятора.
Этот приём относится не только к int, но и к другим типам чисел.
Как сконвертировать строку или CharSequence в int?
Если у вас тип CharSequence, то его можно сконвертировать сначала в строку при помощи метода toString(), а потом в int.
Метод parseInt() предпочтительнее метода valueOf():
Как сконвертировать число в строку?
Если сложить число и строку, то Java автоматически конвертирует число в строку. Пользуясь этим свойством, программисты часто прибавляют к числу пустую строку. Но лучше использовать метод valueOf():
Добавить ведущие нули
Если мы хотим получить строку из числа, добавим при этом несколько нулей вначале, то поможет метод format(), только учитывайте число цифр в самом числе.
Тип long
Тип long — это 64-битный тип со знаком, используемый в тех случаях, когда используется очень большое значение, которое не способен хранить тип int. Например, чтобы вычислить расстояние, которое прошёл солнечный луч от солнца до зеркала, превратившись в солнечного зайчика, за которым безуспешно охотится котёнок, вам понадобится именно этот тип.
Можно использовать символы l или L для обозначения числа типа long. Рекомендую использовать заглавную букву, чтобы избежать возможной путаницы. Например, напишем пример:
Запустив пример, вы увидите ответ 101. Почему так получилось? А потому что последний символ — это не единица, а символ l. Присмотритесь внимательнее. Если бы мы написали long night = 101L, то не ломали бы голову себе.
Конвертируем строку в данный тип.
Класс Long является оболочкой для данного типа. Без необходимости не используйте в Android класс Long.
Типы с плавающей точкой
Числа с плавающей точкой (иногда их называют действительными числами) применяются при вычислении выражений, в которых требуется точность до десятичного знака. Например, это может быть вычисление квадратного корня, значений синуса, косинуса и т.п. Существует два типа с плавающей точкой: float и double, которые представляют числа одинарной и двойной точности.
Слово «плавающая» означает, что десятичная точка может располагаться в любом месте (она «плавает»). Вот коты плавать не особенно любят, поэтому они не float и не double.
Тип float
Тип float определяет значение одинарной точности, которое занимает 32 бит. Переменные данного типа удобны, когда требуется дробная часть без особой точности, например, для денежных сумм.
Рекомендуется добавлять символ F или f для обозначения этого типа, иначе число будет считаться типом double.
Конвертируем из строки.
Класс Float является оболочкой для данного типа. Без необходимости не используйте в Android класс Float.
Также есть специальный класс BigDecimal для проведения арифметических действий повышенной точности (финансовые расчёты).
Тип double
Тип double обеспечивает двойную точность, что видно из его названия (double — двойная). Занимает 64 бит для хранения значений. Многие математические функции возвращают значения типа double. Кстати, современные процессоры оптимизированы под вычисления значений двойной точности, поэтому они предпочтительнее, чем тип float.
Тип double содержит не только числа, но и слова. Сейчас вам докажу. Разделим число типа double на ноль. Ошибки не произойдёт.
Пример вернёт значение Infinity (Бесконечность). Если разделить отрицательное число на ноль, то вернётся -Infinity.
А что произойдёт, если сложить две бесконечности? Если рассуждать логически, то сломается интернет, наступит конец света или можно вызвать Волдеморта. Я долго не решался, но потом набрался храбрости и попробовал.
Вернулось ещё одно слово — NaN. Что это вообще? Может должно вернуться Nyan — ну вы знаете, это странный котик, который летит бесконечно в космосе, оставляя за собой шлейф из радуги.
Умножать две бесконечности я побоялся. И вам не советую.
Класс Double является оболочкой для данного типа. Без необходимости не используйте в Android класс Double.
Конвертация строки в double
Есть несколько вариантов.
Конвертация double в строку
При работе с числами double следует держать ухо востро. Рассмотрим пример конвертации трёх чисел.
Первые два числа нормально преобразовались, а вот третье число преобразовалось в строку в странном виде (на самом деле это научное представление числа). И это может источником проблемы при передаче строки куда-нибудь, например, на сервер. Если сервер не ожидает от вас такой подлости, то будет генерировать ошибки из-за странной записи. Нужно найти другие способы конвертации.
Первый способ — используем String.format().
Последний пример самый подходящий для нас, но вам нужно знать, сколько знаков идёт после десятичной точки. Остальные два пригодятся, если число можно округлить.
Второй способ — метод Double.toString(). У меня метод превратил число в «непонятную» строку. А у некоторых этот пример возвращал строку в нормальном виде. Не заслуживает доверия.
Третий способ — добавить пустую строку. В Android не помогло, хотя тоже утверждается, что у кого-то выводится в нормальном виде. Врут, наверное.
Четвёртый экзотический способ, которым редко пользуются — DecimalFormat.
Символы (тип char)
Для хранения символов Java использует специальный тип char. Он отличается от типа char в языках C/C++, где представляет собой целочисленный тип с размером 8 бит. В Java для char используется кодировка Unicode и для хранения Unicode-символов используется 16 бит или 2 байта. Диапазон допустимых значений — от 0 до 65536 (отрицательных значений не существует).
Из примера выше видно, что переменной можно присвоить код символа или непосредственно сам символ, который следует окружить одинарными кавычками. Попробуйте запустить пример и посмотреть, какое слово получится из трёх указанных символов.
Не следует путать символ ‘a’ со строкой «a», состоящей из одного символа. На экране монитора они выглядят одинаково, но в программах ведут себя по разному.
Стандартные символы ASCII можно выводить сразу. Если нужно вывести специальный символ из Unicode, то можно воспользоваться шестнадцатеричным представлением кода в escape-последовательности — вы указываете обратную наклонную черту и четыре цифры после u. Например:
Хотя тип char используется для хранения Unicode-символов, его можно использовать как целочисленный тип, используя сложение или вычитание.
В результате получим:
Если вы думаете, что увеличив значение переменной ch1 ещё на одну единицу, получите символ «й», то глубоко заблуждаетесь.
Чтобы узнать, какой символ содержится в значении переменной, заданной как int, можно воспользоваться двумя специальными методами из класса EncodingUtils:
Для стандартных символов ASCII:
Для расширенной таблицы символов:
Методы работают со строками, но если мы используем строку из одного символа, то получим то, что нам нужно.
В упрощённом виде, если работаем со стандартными символами ASCII (on 0 до 127), то можно получить символ из int ещё проще.
Класс Character
Класс Character является оболочкой вокруг типа char. Чтобы получить значение типа char, содержащее в объекте класса Character, вызовите метод charValue().
С классом Character редко имеют дело в Android, но помните, что класс содержит огромное количество констант и методов. Например, можно определить, является ли символ цифрой или буквой, или написан ли символ в нижнем или в верхнем регистре.
Булевы значения
Тип boolean предназначен для хранения логических значений и может принимать только одно из двух возможных значений: true или false. Данный тип всегда возвращается при использовании операторов сравнения (больше, меньше, равно, больше или равно, меньше или равно, не равно). Также он используется в управляющих операторах if и for.
В отличие от реальной жизни, где вполне может состояться диалог:
В компьютерной программе нужно чётко определиться — истина или ложь.
В операторах if используется укороченная запись при значении true:
Java сам поймёт, что переменную check нужно сравнить с true.
Класс Boolean
Класс Boolean является оболочкой вокруг значений типа boolean. Чтобы получить значение типа boolean из объекта класса Boolean, используйте метод booleanValue(). Тип boolean использует 4 байт памяти, а Boolean — 16. Вывод понятен?
Ещё один совет, применимый ко всем типам. Допустим, нам нужно объявить 32 переменных типа boolean:
Умножаем 4 байта на 32 переменных и получаем 128 байт занятой памяти. А если объявим массив:
Считаем: 4 + 8 + 8 + 32 * 1 = 52. С учётом выравнивания памяти по 8 байт, получаем не 52, а 56. Всё равно меньше, чем в первом примере.
Конвертируем строку в булево значение.
Конвертируем булево значение в строку.
Приведение типов
Когда мы производим какие-то действия с переменными, то нужно следить за типами. Нельзя умножать котов на футбольные мячи, это противоречит здравому смыслу. Также и с переменными. Если вы присваиваете переменной одного типа значение другого типа, то вспоминайте теорию. Например, вы без проблем можете присвоить значение типа int переменной типа long, так как все числа из диапазона типа int гарантировано помещаются в диапазон чисел long. В этом случае Java выполнит преобразование автоматически, вы даже ничего не заметите.
Представим обратную картину — мы хотим присвоить переменной типа byte значение типа double. Java не сможет автоматически выполнить ваше желание. Не все числа типа double могут стать числом типа byte. Но часть чисел может, например, число 9. В таком случае используется так называемое приведение типов, чтобы подсказать Java о допустимости операции.
Итак, автоматическое преобразование типов осуществляется, если оба типа совместимы и длина целевого типа больше длины исходного типа. В этом случае происходит преобразование с расширением. Вы всегда можете преобразовать любое число типа byte в число типа int. Такая операция произойдёт без вашего участия автоматически.
Таблица выглядит следующим образом.
Сплошные линии обозначают преобразования, выполняемые без потери данных. Штриховые линии говорят о том, что при преобразовании может произойти потеря точности.
Типы целых чисел и чисел с плавающей точкой совместимы частично. Например, число 5 вполне может быть числом с плавающей точкой (5.0).
Совсем не совместимы, например, char и boolean.
С автоматическим приведением мы разобрались. Рассмотрим вариант, когда нужно преобразовать число типа int в число типа byte. Преобразование автоматически невозможно, поскольку byte меньше int. Но, например, число 99 вполне можно использовать и как int и как byte. В этом случае используется явное приведение типов, то есть преобразование из одного типа в другой (преобразование с сужением).
Выглядит это следующим образом:
Как видите, вы в скобках указываете тип, к которому нужно явно привести переменную.
Существует ещё вариант приведения с усечением. Это когда число с плавающей точкой приводится к целочисленному типу. В этом случае отбрасывается дробная часть (хвост). Например, число 3.14 будет усечено до числа 3:
Если размер целочисленной части слишком велик для целочисленного типа, то значение будет уменьшено до результата деления по модулю на диапазон целевого типа.
Например, попробуйте преобразовать число 454.874 в тип byte:
У меня вывелся удивительный результат: b равно -58.
Рассмотрим такой пример. Допустим у нас есть выражение, где промежуточное значение может выходить за пределы допустимого диапазона:
При умножении переменных a * b промежуточный результат вышел за пределы диапазона допустимых значений для типов byte. Java во время вычисления промежуточных результатов автоматически повышает тип каждого операнда до int и ошибки не происходит.
Это удобно, но может поставить в тупик в следующем примере:
С виду всё правильно. Если не слишком больше число типа byte, а итоговый результат тоже не выходит за диапазон допустимых значений. Но Java не позволит вам написать подобный код. Происходит следующее. Во время вычисления выражения тип операндов был автоматически повышен до int, как об этом говорилось выше. При этом тип результата тоже был повышен до int. Получается, что результат вычисления равен типу int, а мы пытаемся его присвоить переменной b, которая у нас объявлена как byte. И это несмотря на то, что итоговый результат может быть типом byte. Как же выйти из этого положения? Следует использовать явное приведение типов:
Мы рассмотрели единичные примеры. Пора обобщить и запомнить несколько правил.
Типы всех значений byte, short, char повышаются до типа int, как это было рассмотрено выше.
Если один операнд имеет тип long, то тип всего выражения повышается до long.
Если один операнд имеет тип float, то тип всего выражения повышается до float.
Если один операнд имеет тип double, то тип всего выражения повышается до double.
В первом промежуточном выражении (f * b) тип переменной b повышается до float и промежуточный результат также становится float. В следующем выражении (i / c) тип у переменной c повышается до int и промежуточный результат также становится типом int. В выражении (d * s) тип переменной s повышается до double и промежуточное выражение также становится double. В результате у нас появились три промежуточные значения типов: float, int, double. При сложении float и int мы получаем float, затем при вычитании с использованием float и double тип повышается до double, который и становится окончательным типом результата выражения.
Источник