Binary Literals
In Java SE 7, the integral types ( byte , short , int , and long ) can also be expressed using the binary number system. To specify a binary literal, add the prefix 0b or 0B to the number. The following examples show binary literals:
Binary literals can make relationships among data more apparent than they would be in hexadecimal or octal. For example, each successive number in the following array is rotated by one bit:
In hexadecimal, the relationship among the numbers is not readily apparent:
You can use binary integral constants in code that you can verify against a specifications document, such as a simulator for a hypothetical 8-bit microprocessor:
Какой тип имеет литерал 0x0bp3
Литералы — это константы, которые записаны по правилам языка Java. Рассмотрим сначала целочисленные литералы. Приведем примеры целочисленных литералов.
111 — десятичное (десятеричное) число
056 — число 46 в восьмеричной форме
0 х АВ — 171 в шестнадцатеричной форме
В языке Java возможны три системы счисления: десятичная (десятеричная), восьмеричная и шестнадцатеричная. Числа в десятичной форме — это числа с основанием 10, числа в восьмеричной форме — это числа с основанием 8, числа в шестнадцатеричной форме — числа с основанием 16. Записи чисел в восьмеричной форме начинаются с 0, далее каждая цифра числа должна быть от 0 до 7. Преобразуются они в десятичные числа так: рассмотрим, например, число 056 в восьмеричной форме. В десятичной форме это число записывается так.
Запись числа в шестнадцатеричной форме начинается с символов 0х, а последующие цифры должны быть от 0 до 15. Поскольку, например, число — это 2 цифры, а нужно записать его одной цифрой, то числа от 10 до 15 записываются буквами от А до f. Рассмотрим правила перехода шестнадцатеричных чисел в десятичные. Возьмем, например, число 0 х АВ. В десятичной форме это число будет записываться так.
10 х 16 + 11 = 171.
Записи числа с типом данных long («длинные целые числа» — об этом далее) обычно имеют на конце символ 1 (чтобы отличить их от целочисленных констант типа int — простых чисел).
Рассмотрим теперь литералы для чисел с плавающей точкой.
Эти литералы, как и целочисленные, могут иметь знаки «+» и (т.е. быть положительными или отрицательными), иметь в записи точку, которая разделяет целую и дробную часть, а также букву е и следом за ней — степень, в которую необходимо возвести число (если степень положительная, знак «+» можно не указывать).
Рассмотрим теперь, как выглядят символьные литералы.
Символьные литералы должны заключаться в одинарные кавычки. Среди символьных литералов есть так называемые еsсаре-последовательности, которые позволяют произвести какую-либо операцию, например, перевести курсор на новую строку или вывести обратную косую черту.
Они представляют собой набор последовательностей вида \uaaaaa, где вместо а могут быть какие-либо символы или числа. Однако есть специальные символы, которые соответствуют еsсаре-последовательностям. Эти специальные символы представлены в табл. 2.1.
Таблица 2.1. Специальные символы, соответствующие еsсаре-последовательностям
Базовые типы данных и литералы Java
В языке Java используются базовые типы данных, значения которых размещаются в стековой памяти (stack). Эти типы обеспечивают более высокую производительность вычислений по сравнению с объектами. Кроме этого, для каждого базового типа имеются классы-оболочки, которые инкапсулируют данные базовых типов в объекты, располагаемые в динамической памяти (heap).
По
умолчанию
Значения
(диапазон или максимум)
–32768..32767
-2147483648..2147483647
922372036854775807L
3.40282347E+38
1.797693134486231570E+308
В Java используются целочисленные литералы, например: 35 – целое десятичное число, 071 – восьмеричное значение, 0х51 – шестнадцатеричное значение. Целочисленные литералы по умолчанию относятся к типу int. Если необходимо определить длинный литерал типа long, в конце указывается символ L (например: 0xffffL). Если значение числа больше значения, помещающегося в int (2147483647), то Java автоматически предполагает, что оно типа long. Литералы с плавающей точкой записываются в виде 1.618 или в экспоненциальной форме 0.112E-05 и относятся к типу double, таким образом, действительные числа относятся к типу double. Если необходимо определить литерал типа float, то в конце литерала следует добавить символ F. Символьные литералы определяются в апострофах (‘a‘, ‘\n‘, ‘\141’, ‘\u005a‘ ). Для размещения символов используется формат Unicode, в соответствии с которым для каждого символа отводится два байта. В формате Unicode первый байт содержит код управляющего символа или национального алфавита, а второй байт соответствует стандартному ASCII коду, как в C++. Любой символ можно представить в виде ‘\ucode‘, где code представляет двухбайтовый шестнадцатеричный код символа. Java поддерживает управляющие символы, не имеющие графического изображения;
‘\n‘– новая строка, ‘\r‘ – переход к началу, ‘\f‘ – новая страница, ‘\t‘– табуляция, ‘\b‘ – возврат на один символ, ‘\uxxxx‘ – шестнадцатеричный символ Unicode, ‘\ddd‘– восьмеричный символ и др. Начиная с J2SE 5.0 используется формат Unicode 4.0. Поддержку четырехбайтным символам обеспечивает наличие специальных методов в классе Character.
К литералам относятся булевские значения true и false, а также null – значение по умолчанию для ссылки на объект. При инициализации строки всегда создается объект класса String – это не массив символов и не строка. Строки, заключенные в двойные апострофы, считаются литералами и размещаются в пуле литералов, но в то же время такие строки представляют собой объекты.
В арифметических выражениях автоматически выполняются расширяющие преобразования типа byte à short à int à long à float à
double. Java автоматически расширяет тип каждого byte или short операнда до int в выражениях. Для сужающих преобразований необходимо производить явное преобразование вида (тип)значение. Например:
byte b = (byte)128; //преобразование int в byte
Указанное в данном примере преобразование необязательно, так как в операциях присваивания литералов при инициализации преобразования выполняются автоматически. При инициализации полей класса и локальных переменных с использованием арифметических операторов автоматически выполняется приведение литералов к объявленному типу без необходимости его явного указания, если только их значения находятся в допустимых пределах, кроме инициализации объектов классов-оболочек. Java не позволяет присваивать переменной значение более длинного типа, в этом случае необходимо явное преобразование типа. Исключение составляют операторы инкремента (++), декремента (–) и сокращенные операторы (+=, /= и т.д.). При явном преобразовании (тип)значение возможно усечение значения.
Имена переменных не могут начинаться с цифры, в именах не могут использоваться символы арифметических и логических операторов, а также символ ‘#’. Применение символов ‘$’ и ‘_’ допустимо, в том числе и в первой позиции имени.
/* пример # 1 : типы данных, литералы и операции над ними :TypeByte.java */
package chapt02;
public class TypeByte , в котором она объявлена.
Java Blog
Переменные — это не что иное, как зарезервированные ячейки памяти для хранения значений. Это означает, что когда вы создаете переменную, вы резервируете некоторое место в памяти.
На основе типа данных переменной операционная система выделяет память и решает, что можно сохранить в зарезервированной памяти. Таким образом, назначая переменным разные типы данных, вы можете хранить в этих переменных целые, десятичные дроби или символы.
В Java доступны два типа данных:
- Примитивные типы данных
- Ссылочные/Объектные типы данных
Примитивные типы данных
Java поддерживает восемь примитивных типов данных. Примитивные типы данных предопределены языком и названы ключевым словом.
- Тип данных byte — это 8-битовое знаковое целое число с дополнением до двух.
- Минимальное значение -128 (-2^7)
- Максимальное значение 127 (включительно)(2^7 -1)
- Значение по умолчанию — 0
- Тип данных byte используется для экономии места в больших массивах, в основном вместо int, поскольку byte в четыре раза меньше int.
- Пример: byte a = 100, byte b = -50
- Тип данных short — это 16-битное знаковое целое число с дополнением до двух.
- Минимальное значение -32,768 (-2^15)
- Максимальное значение — 32,767 (включительно) (2^15 -1)
- Тип данных short также может использоваться для экономии памяти как byte тип данных. short в 2 раза меньше int
- Значение по умолчанию — 0.
- Пример: short s = 10000, short r = -20000
- Тип данных int — это 32-битное знаковое целое число с дополнением до двух.
- Минимальное значение — 2,147,483,648 (-2^31)
- Максимальное значение — 2,147,483,647 (включительно) (2^31 -1)
- Целое число (int) обычно используется в качестве типа данных по умолчанию для целых значений, если нет проблем с памятью.
- Значение по умолчанию — 0
- Пример: int a = 100000, int b = -200000
- Тип данных long — это 64-битное целое число с дополнением до двух со знаком.
- Минимальное значение -9,223,372,036,854,775,808(-2^63)
- Максимальное значение — 9,223,372,036,854,775,807 (включительно)(2^63 -1)
- Этот тип используется, когда требуется более широкий диапазон, чем int
- Значение по умолчанию — 0L
- Пример: long a = 100000L, long b = -200000L
- Тип данных float представляет собой 32-битное число с плавающей запятой одинарной точности IEEE 754
- float в основном используется для экономии памяти в больших массивах чисел с плавающей запятой.
- Значение по умолчанию — 0.0f
- Тип данных float никогда не используется для точных значений, таких как валюта
- Пример: float f1 = 234.5f
- Тип данных double — это 64-битный IEEE 754 с плавающей запятой двойной точности
- Этот тип данных обычно используется как тип данных по умолчанию для десятичных значений, обычно это выбор по умолчанию.
- Тип данных double никогда не следует использовать для точных значений, таких как валюта.
- Значение по умолчанию — 0.0d
- Пример: double d1 = 123.4
- boolean тип данных представляет один бит информации
- Возможны только два значения: true и false.
- Этот тип данных используется для простых флагов, которые отслеживают true/false условия.
- Значение по умолчанию — false
- Пример: boolean one = true
- Тип данных char — это один 16-битный символ Unicode
- Минимальное значение — ‘\u0000’ (или 0)
- Максимальное значение — ‘\uffff’ (или 65 535 включительно).
- Тип данных char используется для хранения любого символа
- Пример: char letterA = ‘A’
Ссылочные типы данных
- Ссылочные переменные создаются с использованием определенных конструкторов классов. Они используются для доступа к объектам. Эти переменные объявлены как имеющие определенный тип, который нельзя изменить. Например, Car, Animal и т. д.
- Объекты классов и различные типы переменных массива подпадают под ссылочный тип данных.
- Значение по умолчанию любой ссылочной переменной равно null.
- Ссылочная переменная может использоваться для ссылки на любой объект объявленного типа или любого совместимого типа.
- Пример: Animal animal = new Animal(«cat»);
Литералы Java
Литерал — это представление исходного кода фиксированного значения. Они представлены прямо в коде без каких-либо вычислений.
Литералы могут быть присвоены любой переменной примитивного типа. Например:
byte, int, long и short также могут быть выражены в десятичной (основание 10), шестнадцатеричной (основание 16) или восьмеричной (основание 8) системе счисления.
Префикс 0 используется для обозначения восьмеричного, а префикс 0x указывает шестнадцатеричный при использовании этих систем счисления для литералов. Например:
Строковые литералы в Java указываются, как и в большинстве других языков, путем заключения последовательности символов между парой двойных кавычек. Примеры строковых литералов:
Литералы String и char типов могут содержать любые символы Юникода. Например:
Язык Java также поддерживает несколько специальных escape-последовательностей для литералов String и char.
Java Language
литералы
Шестнадцатеричные, восьмеричные и двоичные литералы
hexadecimal число — это значение в базе 16. Есть 16 цифр, 0-9 и буквы AF (случай не имеет значения). AF представляет 10-16 .
octal число — это значение в базе-8 и использует цифры 0-7 .
binary число — это значение в базе-2 и использует цифры 0 и 1 .
Все эти числа приводят к тому же значению, 110 :
Обратите внимание, что бинарный литерал синтаксис был введен в Java 7.
Октальный литерал может быть легко ловушкой для семантических ошибок. Если вы определяете ведущее '0' для ваших десятичных литералов, вы получите неправильное значение:
Использование подчеркивания для улучшения удобочитаемости
Начиная с Java 7, было возможно использовать один или несколько символов подчеркивания (_) для разделения групп цифр в литерале примитивного числа, чтобы улучшить их читаемость.
Например, эти два объявления эквивалентны:
Это можно применить ко всем литералам примитивных чисел, как показано ниже:
Это также работает с использованием префиксов для двоичных, восьмеричных и шестнадцатеричных баз:
Существует несколько правил о подчеркиваниях, которые запрещают их размещение в следующих местах:
- В начале или в конце ряда (например , _123 или 123_ не действительны)
- Рядом с десятичной точкой в плавающей точке буквальной (например , 1._23 или 1_.23 не действительны)
- Перед суффиксом F или L (например , 1.23_F или 9999999_L не действительны)
- В местах , где ожидается строка цифр (например , 0_xFFFF не действует)
Эквивалентные последовательности в литералах
Строковые и символьные литералы обеспечивают механизм эвакуации, который позволяет выразить коды символов, которые в противном случае не были бы разрешены в литерале. Эквивалентная последовательность состоит из символа обратной косой черты ( \ ), за которым следует одна или несколько других символов. В обоих символах одинаковые последовательности являются строковыми литералами.
Полный набор управляющих последовательностей выглядит следующим образом:
| Эквивалентная последовательность | Имея в виду |
|---|---|
| \\ | Обозначает символ обратной косой черты ( \ ) |
| \' | Обозначает символ одной кавычки ( ' ) |
| \" | Обозначает символ с двойной кавычкой ( " ) |
| \n | Обозначает символ линии ( LF ) |
| \r | Обозначает символ возврата каретки ( CR ) |
| \t | Обозначает символ горизонтальной вкладки ( HT ) |
| \f | Обозначает символ подачи формы ( FF ) |
| \b | Обозначает символ backspace ( BS ) |
| \<octal> | Обозначает код символа в диапазоне от 0 до 255. |
<octal> в приведенном выше состоит из одной, двух или трех восьмеричных цифр (от 0 до 7), которые представляют число от 0 до 255 (десятичное).
Обратите внимание, что обратная косая черта, сопровождаемая любым другим символом, является недопустимой управляющей последовательностью. Неверные escape-последовательности рассматриваются как ошибки компиляции JLS.
Юникодные экраны
В дополнение к последовательностям escape-последовательности строк и символов, описанным выше, Java имеет более общий механизм экранирования Unicode, как определено в JLS 3.3. Unicode Escapes . Выделение Unicode имеет следующий синтаксис:
Выделение Unicode сопоставляется компилятором Java с символом (строго говоря, 16-разрядным блоком кода Unicode) и может использоваться в любом месте исходного кода, в котором действительный отображаемый символ действителен. Он обычно используется в символьных и строковых литералах, когда вам нужно представить символ не-ASCII в литерале.
Исключение в регулярных выражениях
Десятичные целые литеры
Целочисленные литералы предоставляют значения, которые могут использоваться там, где вам нужен byte , short , int , long или char . (В этом примере основное внимание уделяется простым десятичным формам. В других примерах объясняется, как литералы в восьмеричных, шестнадцатеричных и двоичных выражениях, а также использование подчеркиваний для повышения удобочитаемости.)
Обычные целые литералы
Простейшей и наиболее распространенной формой целочисленного литерала является десятичный целочисленный литерал. Например:
Вы должны быть осторожны с ведущими нулями. Ведущий нуль приводит к тому, что целочисленный литерал интерпретируется как восьмеричный, а не десятичный.
Целочисленные литералы неподписанны. Если вы видите что — то вроде -10 или +10 , это на самом деле выражение , использующее одинарных — и унарных + операторов.
Диапазон целочисленных литералов этой формы имеет внутренний тип int и должен находиться в диапазоне от 0 до 2 31 или 2 147 483 648.
Обратите внимание, что 2 31 равно 1 больше Integer.MAX_VALUE . Литералы от 0 до до 2147483647 можно использовать в любом месте, но это ошибка компиляции использовать 2147483648 без предшествующего одноместной — оператора. (Другими словами, он зарезервирован для выражения значения Integer.MIN_VALUE .)
Длинные целые литералы
Литералы типа long выражаются добавлением суффикса L Например:
Обратите внимание, что различие между int и long литералами значимо в других местах. Например
Булевы литералы
Булевы литералы являются простейшим из литералов на языке программирования Java. Два возможных boolean значения представлены литералами true и false . Они чувствительны к регистру. Например:
Строковые литералы
Строковые литералы предоставляют наиболее удобный способ представления строковых значений в исходном коде Java. Строковый литерал состоит из:
- Открывающий символ двойной кавычки ( " ).
- Нулевой или более других символов, которые не являются ни двойным кавычкой, ни символом прерывания строки. (Символ обратной косой черты ( \ ) изменяет значение последующих символов, см. Последовательности Escape в литералах .)
- Закрывающий символ двойной кавычки.
Обратите внимание, что один строковый литерал может не охватывать несколько строк исходного кода. Это ошибка компиляции для разрыва строки (или конца исходного файла) перед закрывающей двойной кавычкой литерала. Например:
Длинные строки
Если вам нужна строка, которая слишком длинная, чтобы поместиться на линии, обычный способ выразить ее состоит в том, чтобы разбить ее на несколько литералов и использовать оператор конкатенации ( + ) для объединения фигур. Например
Выражение, подобное выше, состоящее из строковых литералов и + удовлетворяет требованиям как константное выражение . Это означает, что выражение будет оцениваться компилятором и представлено во время выполнения одним объектом String .
Интернирование строковых литералов
Когда файл класса, содержащий строковые литералы, загружается JVM, соответствующие объекты String интернируются системой выполнения. Это означает, что строковый литерал, используемый в нескольких классах, занимает больше места, чем если бы он использовался в одном классе.
Дополнительные сведения о интернировании и пуле строк см. В примере String pool и кучи памяти в разделе «Строки».
Нулевой литерал
Нулевой литерал (записанный как null ) представляет одно и единственное значение нулевого типа. вот несколько примеров
Нулевой тип довольно необычен. У него нет имени, поэтому вы не можете выразить его в исходном коде Java. (И у него нет представления во время выполнения).
Единственной целью нулевого типа является тип null . Это присвоение, совместимое со всеми ссылочными типами, и может быть введено для любого ссылочного типа. (В последнем случае приведение не требует проверки типа времени выполнения).
Наконец, null имеет свойство, что null instanceof <SomeReferenceType> будет оцениваться как false , независимо от типа.
Литералы с плавающей запятой
Литералы с плавающей запятой предоставляют значения, которые можно использовать там, где вам нужен float или double экземпляр. Существует три типа литералов с плавающей запятой.
- Простые десятичные формы
- Масштабированные десятичные формы
- Шестнадцатеричные формы
(Синтаксические правила JLS объединяют две десятичные формы в одну форму. Мы относимся к ним отдельно для удобства объяснения.)
Существуют разные литературные типы для float и double литералов, выраженные с использованием суффиксов. Различные формы используют буквы для выражения разных вещей. Эти буквы нечувствительны к регистру.
Простые десятичные формы
Простейшая форма литерала с плавающей запятой состоит из одной или нескольких десятичных цифр и десятичной точки ( . ) И необязательного суффикса ( f , F , d или D ). Необязательный суффикс позволяет указать, что литерал представляет собой значение float ( f или F ) или double ( d или D ). Значение по умолчанию (если суффикс не указан) является double .
Фактически, десятичные цифры, за которыми следует суффикс, также являются литералами с плавающей запятой.
Значение десятичного литерала — это число с плавающей запятой IEEE, которое ближе всего к математическому вещественному числу бесконечной точности, обозначенному десятичной формой с плавающей запятой. Это концептуальное значение преобразуется в двоичное представление с плавающей точкой IEEE с округлением до ближайшего . (Точная семантика десятичного преобразования указана в javadocs для Double.valueOf(String) и Float.valueOf(String) , имея в виду, что существуют различия в синтаксисе числа.)
Масштабированные десятичные формы
Масштабированные десятичные формы состоят из простой десятичной дроби с частью экспоненты, введенной E или e , и за ней следует целое число со знаком. Часть экспоненты представляет собой короткую руку для умножения десятичной формы на десять, как показано в приведенных ниже примерах. Существует также дополнительный суффикс, чтобы отличать float и double литералы. Вот некоторые примеры:
Размер литерала ограничен представлением ( float или double ). Это ошибка компиляции, если масштабный коэффициент приводит к слишком большому или слишком маленькому значению.
Шестнадцатеричные формы
Начиная с Java 6, можно выразить литералы с плавающей запятой в шестнадцатеричном формате. Шестнадцатеричная форма имеет аналогичный синтаксис для простых и масштабированных десятичных форм со следующими отличиями:
- Каждый шестнадцатеричный литерал с плавающей запятой начинается с нуля ( 0 ), а затем x или X
- Цифры номера (но не части экспоненты!) Также включают шестнадцатеричные цифры от a до f и их прописные эквиваленты.
- Показатель является обязательным и вводится буквой p (или P ) вместо e или E Показатель представляет собой коэффициент масштабирования, который представляет собой мощность 2 вместо мощности 10.
Вот некоторые примеры:
Совет. Поскольку шестнадцатеричные формы с плавающей запятой не знакомы большинству программистов на Java, рекомендуется использовать их экономно.
подчеркивания
Начиная с Java 7, символы подчеркивания допускаются в цифровых строках во всех трех формах литералов с плавающей запятой. Это относится и к «экспоненциальным» частям. См. Раздел Использование подчеркивания для повышения удобочитаемости .
Особые случаи
Это ошибка компиляции, если литерал с плавающей запятой обозначает число, которое слишком велико или слишком мало для представления в выбранном представлении; т.е. если число будет переполняться до + INF или -INF или underflow до 0.0. Тем не менее, для литерала законно представлять ненулевое денормализованное число.
Синтаксис букв с плавающей запятой не предоставляет буквенных представлений для специальных значений IEEE 754, таких как значения INF и NaN. Если вам нужно выразить их в исходном коде, рекомендуется использовать константы, определенные java.lang.Float и java.lang.Double ; например Float.NaN , Float.NEGATIVE_INFINITY и Float.POSITIVE_INFINITY .
Литералы символов
Литералы символов предоставляют наиболее удобный способ выражения значений char в исходном коде Java. Литеральный символ состоит из:
Литералы. Идентификаторы. Ключевые слова. Комментарии
Литералы представляют собою фиксированные значения (константы), которые имеют определенный тип. Более подробно о примитивных типах данных можно прочитать здесь.
Тип литерала определяется его значением. Чаще всего литералы встречаются в выражениях, параметрах функций (методов).
Примеры литералов:
⇑
2. Каким образом определяются литералы целочисленных типов?
Тип литерала компилятор распознает по его значению. По умолчанию целочисленные литералы имеют тип int . В языке Java целочисленный литерал типа int имеет разрядность 32 бита.
Пример целочисленных литералов типа int :
Для того, чтобы целочисленный литерал имел тип long , нужно дополнить значения литерала символами ‘ l ‘ или ‘ L ‘.
Пример целочисленных литералов типа long :
⇑
3. Каким образом происходит присваивание литерала переменным типов byte и short ?
Литерал типа int может присваиваться переменным типов byte , short если значение литерала находится в границах допустимых значений данных типов.
Пример. Присваивание литералов переменным типов byte и short .
Если забрать комментарии из строки
то компилятор выдаст сообщение об ошибке:
⇑
4. Как записать целочисленный литерал в восьмеричной или шестнадцатеричной системе исчисления?
Для записи литерала в восьмеричной системе исчисления перед ним ставится символ ‘ 0 ‘ (ноль).
Для записи литерала в шестнадцатеричной системе исчисления нужно перед значением литерала поставить символы ‘ 0x ‘ или ‘ 0X ‘.
Пример использования литералов в восьмеричной и шестнадцатеричной системах исчисления.
Если попробовать написать:
то компилятор выдаст следующее сообщение об ошибке:
Это означает, что цифра ‘9’ не входит в множество цифр восьмеричной системы исчисления.
⇑
5. Какие особенности представления литералов с плавающей точкой в языке Java ?
Литералы с плавающей точкой могут быть представлены в стандартной или экспоненциальной форме.
По умолчанию, литералы с плавающей точкой имеют тип double . Если литералу принудительно необходимо указать тип double , то после его значения нужно добавить символ ‘ d ‘ или ‘ D ‘.
Если литералу нужно задать тип float , тогда его значение дополняется символом ‘ f ‘ или ‘ F ‘.
Примеры литералов с плавающей запятой.
⇑
6. Каким образом представляются литералы с плавающей точкой в экспоненциальной форме?
В экспоненциальной форме к стандартной форме литерала добавляется символ ‘ e ‘ или ‘ E ‘. После символа ‘ e ‘ или ‘ E ‘ следует число, которое есть степенью числа 10. На это число нужно помножить данное число.
Пример представления чисел с плавающей запятой в экспоненциальной форме:
⇑
7. Каким образом представляются литералы с плавающей точкой в шестнадцатеричной системе исчисления?
Язык Java разрешает представлять литералы с плавающей точкой в шестнадцатеричной системе исчисления. В этом случае литерал состоит из таких частей:
- знак ‘ — ‘, что означает, что число отрицательное;
- символ ‘ 0x ‘ или ‘ 0X ‘ (означает, что литерал записанный в шестнадцатеричной системе исчисления);
- непосредственно число в стандартной форме записи (например 2.3);
- символ ‘ p ‘ или ‘ P ‘;
- целое число, которое есть степенью числа 2 на которое множится данное число.
Пример. Представление литералов в шестнадцатеричной системе исчисления.
⇑
8. Как в Java представляются логические литералы?
В языке Java логические литералы могут быть двух значений: true или false . Логические литералы могут быть присвоены переменным типа boolean .
Пример.
⇑
9. Как в Java записываются символьные литералы?
Символьные литералы – это символы, которые поддерживают набор символов Юникод ( Unicode ). Один символ занимает в памяти 16 бит (2 байта).
Есть множество символов, которые по разным причинам нельзя представить непосредственно. В этом случае используются управляющие последовательности.
Примеры символьных литералов.
⇑
10. Что такое управляющие последовательности символов?
Управляющие последовательности позволяют отображать символы, которые:
- невозможно ввести с клавиатуры (например, символ новой строки);
- нужно представить в восьмеричной форме;
- нужно представить в шестнадцатеричной форме.
В Java существуют следующие управляющие последовательности символов:
Пример использования символьных литералов и управляющих последовательностей в программе.
⇑
11. Как отображаются строковые литералы?
Строковые литералы берутся в двойные кавычки.
Примеры строковых литералов.
⇑
12. Что такое идентификаторы в языке программирования Java ?
Идентификаторы используются для именования переменных, методов, классов. В языке Java идентификатор состоит из любой последовательности:
- строчных и прописных букв латинского алфавита;
- цифр от ‘ 0 ‘ до ‘ 9 ‘;
- символа подчеркивания ‘_‘;
- символа денежной единицы (в особых случаях).
Идентификатор обязательно должен начинаться с буквы.
Язык Java распознает строчные и прописные буквы как разные. Это означает, что идентификатор с именем MAX отличается от идентификатора с именем Max – это два разных имени.
Примеры имен идентификаторов:
⇑
13. Что такое ключевые слова?
Ключевые слова – это зарезервированные языком Java слова. Ключевыми словами могут быть операторы, инструкции, утверждения, которые составляют основу языка Java . Ключевые слова нельзя использовать в качестве имен идентификаторов, переменных, классов, методов и т.п.
В языке Java определены следующие ключевые слова:
⇑
14. Какие виды комментариев существуют в языке Java ?
Комментарии разрешают сопровождать программный код объяснениями. Комментарии облегчают чтение деталей программного кода как разработчиками, так и сторонними программистами.