Зарезервированные слова в Java
В языке Java, как и в любом языке программирования, есть слова, которые имеют особый смысл. Например, return или if или while . Такие слова называются ключевыми ( keywords ) и считаются зарезервированными языком Java.
Вы не можете использовать эти слова в качестве имени переменной, имени метода или класса. Компилятор всегда будет интерпретировать их строго определенным образом. Всего в Java таких слов 54 .
Некоторые из них вы уже знаете, а об остальных мы сейчас поговорим.
2. Примитивные типы
Как вы уже, скорее всего, запомнили, в Java есть 8 примитивных типов, и каждому из них соответствует свое ключевое слово:
- byte
- short
- int
- long
- char
- float
- double
- boolean
- void
Если вы достаточно любознательны, скорее всего, уже пробовали назвать переменную именем int. И конечно же, это у вас не получилось. Именно по причине того, что все имена примитивных типов являются зарезервированными словами.
Также в эту категорию можно отнести тип void .
3. Циклы и ветвления
Циклы и ветвления тоже дают нам немаленький список ключевых слов:
- if
- else
- switch
- case
- default
- while
- do
- for
- break
- continue
Всего 10 слов достаточно, чтобы в языке появились циклы нескольких видов, ветвления, операторы управления прерыванием цикла ( break и continue ) и множественные ветвления ( switch ). Со всеми этими ключевыми словами вы уже знакомы.
4. Исключения
Исключения дают нам 5 ключевых слов:
- try
- catch
- finally
- throw
- throws
Это блок try-catch-finally . Оператор для выбрасывания исключений — throw , и ключевое слово throws для поддержки механизма checked -исключений.
Хорошая новость: вы уже знакомы со всеми ключевыми словами в исключениях, поэтому большую часть работы с исключениями вы уже знаете.
5. Области видимости
Всего три ключевых слова, но вы уже с ними знакомы
- private
- protected
- public
public разрешает доступ к методу/переменной/классу из любого места программы.
private запрещает доступ к методу/переменной/классу из любого места программы. Доступ разрешен только внутри того же класса, что и метод, помеченный модификатором private .
protected работает так же, как и private , но еще разрешает обращаться к методу/переменной/классу из классов-наследников. Преимущества этого модификатора станут вам более понятны, когда вы хорошо разберетесь с ООП и наследованием.
6. Работа с классами
В эту категорию входит 11 ключевых слов:
- class
- interface
- enum
- import
- package
- extends
- implements
- static
- final
- abstract
- default
Их можно разделить на 4 группы.
Первая группа — создание классов: class , interface и enum . С объявлением class’а и enum’а вы уже познакомились. Ключевое слово interface используется для объявления еще одной «разновидности классов» – интерфейсов.
Вторая группа — это уже известные вам ключевые слова package и import. Package используется для того, чтобы описать пакет класса внутри файла класса. А import — чтобы в нашем классе мы могли использовать короткие имена чужих классов.
Ключевые слова extends и implements используются для описания наследования. Их вы рассмотрите в самом начале квеста Java Core.
И наконец, последняя группа — это модификаторы static , final , default и abstract . Про static и final вы уже немного знаете, а ключевое слово abstract используется для того, чтобы сделать класс или метод абстрактным. Детальнее — при изучении наследования в квесте Java Core.
7. Работа с объектами и переменными
Еще 6 ключевых слов используются для работы с объектами, методами и переменными.
- new
- instanceof
- this
- super
- return
- var (начиная с Java 10)
Оператор new используется, чтобы создавать новые объекты — это вы уже знаете.
Оператор instanceof используется, чтобы проверить, что определенная переменная содержит ссылку на объект определенного типа. С ним вы уже тоже знакомы.
Ключевое слово this используется, чтобы решать проблемы с затенением переменных и методов класса. Вы это тоже изучали.
Ключевое слово super — это аналог this , только при обращении к методам и переменным класса-родителя. Класс родитель еще называют суперклассом.
Оператор return используется, чтобы вернуть значение функции, и попутно эту самую функцию завершить.
И наконец, var — это объявление переменной с автовыведением типа. Вы тоже с этим уже знакомы.
8. Многопоточность
Многопоточность на уровне синтаксиса языка Java представлена всего двумя словами.
- synchronized
- volatile
Мы их даже разбирать не будем. Вот доберетесь до квеста Java Multithreading — тогда и начнем.
9. Разное
Так же есть еще 4 уникальных ключевых слова:
- native
- transient
- assert
- strictfp
native — это модификатор, который пишется перед объявлением метода. Он означает, что код метода написан не на Java, а на С++ и встроен в Java-машину (ну или подключаемую DLL-библиотеку). Сама Java-машина, как вы уже, наверное, догадываетесь, тоже написана на C++. Как и многие методы стандартных библиотек.
transient — это модификатор, который пишется перед переменными класса (полями класса). Он просит Java-машину пропустить (игнорировать) переменную при сохранении объекта класса — сериализации. Больше о сериализации вы узнаете в квесте Java Collections.
assert — тоже пришел в наследство от C++. С его помощью в код можно добавить дополнительные проверки (на то, что переменная не равна null, например). Штука в том, что он включается или выключается на этапе компиляции.
Можно собрать проект для внутреннего тестирования, где эти проверки будут осуществляться (включены). А можно их и выключить при компиляции: когда компилируете версию программы, которая будет поставляться пользователям.
Ну а про модификатор strictfp и дополнительную точность процессоров Intel мы даже целую историю рассказывали.
10. Зарезервированы, но не используются
Еще есть два ключевых слова, которые зарезервированы, но не используются.
- const
- goto
Это тоже наследие языка C++, где они есть и используются.
11. Не ключевые слова
Константы true , false и null формально не относятся к ключевым словам. Однако, обладают всеми их особенностями. Вы не можете назвать метод true или переменную false . Компилятор такой код не поймет и компилировать его не будет.
Java reserved keywords.
В языках программирования всегда есть зарезервированные ключевые слова, употребить которые в том или ином контексте невозможно. Хотите написать «String can do anything!”»? Можете написать, вот только программа не скомпилируется, ибо ключевое слово class используется для объявления класса и применить его в качестве имени переменной не получится.
Ниже расположена схема зарезервированных слов в джаве. Все ли слова вам знакомы?
Кто использовал strictfp? А чистый assert без JUnit’a? Есть любители (‘извращений’) сокращений имён переменных до «_»?
Всего JDK 12 имеет 65 зарезервированных слов. В спецификации говорится, что литералы и var — это не совсем ключевые слова, но всё же к ним их можно отнести.
Unused keywords — (‘бесполезные’) не имеющие никакого значения, но в то же время зарезервированные слова. Это нужно, чтобы нерадивые разработчики не создавали путаниц как для человека, так и для машины, если вдруг захотят назвать этим словом переменную или класс.
«Ключевые слова const и goto зарезервированы, хоть и не используются на данный момент. Это может позволить компилятору Java выводить более ясные сообщения об ошибках, если эти ключевые слова C++ будут некорректно использоваться в программах.»
Restricted keywords — а эти слова пришли к нам с модульной системой в JDK 9. Да, их запросто можно использовать в качестве имён переменных или классов, зарезервированы они только в описании модулей. Сделано это для обратной совместимости с написанными ранее программами ради любителей «очевидных» имён переменных.
exports — указывает, что код в конкретном пакете доступен для использования кодом в других модулях.
module — используется для объявления модуля.
open — указывает, что все пакеты в модуле доступны для использования кодом в других модулях.
opens — получает доступ ко всему коду в другом модуле через рефлексию.
provides — предоставляет доступ к интерфейсу сервиса.
requires — указывает зависимость текущего модуля от другого модуля (сервиса).
to — обозначает код, который имеет разрешение на использование определенного фрагмента кода.
transitive — транзитивная зависимость, обозначающая, что если модулю А требуется модуль Б, то модулю Б будет предоставлен доступ к модулю А автоматически.
uses — указывает, что модуль использует интерфейс сервиса.
with — определяет имплементацию предоставляемого интерфейса сервиса.
Type name — restricted local variable type, особое, долгожданное многими слово var, которое нельзя использовать в качестве имени класса, т.к. оно зарезервировано для обозначения «динамической» типизации. В кавычках, ибо на самом деле тип подставляется в процессе компиляции. А вот именем переменной var может запросто являться:
«var — это не совсем ключевое слово, а скорее идентификатор со специальным значением в качестве объявления типа локальной переменной или типа формального параметра лямбда-выражения.»
Used keywords — а эти зарезервированные слова активно используются и их применение в качестве имени переменной или класса недопустимо.
Кстати, имена в джаве регистрозависимы, поэтому допускается следующее написание:
Literals: true & false — это скорее булевские литералы, а null — это скорее null-литерал, нежели ключевые слова, но мы их всё равно любим и используем только по назначению.
Other: “_” (underscore) — до java 9 использование подчёркивания в качестве имён было легально (хоть и аморально). Но с приходом JEP 302 всё изменилось и вскоре подчёркивание стало ключевым словом (или скорее символом?).
«Во многих языках распространено использование подчёркивания для обозначения безымянных лямбда-параметров (и аналогично для параметров методов и исключений):
BiFunction<Integer, String, String> biss = (i, _) -> String.valueOf(i);
Это позволяет добиться более сильной статической проверки неиспользуемых аргументов, а также помечать несколько аргументов как неиспользуемые.»
Приведу ещё описание нескольких наиболее интересных или редких (да, да, это про тебя strictfp) ключевых слов:
void — это не просто обозначение, что метод не возвращает никакого значения. void — это и есть тип возврата. Т.е. методы, помеченные void, на самом деле возвращают тип void. Сам по себе void определен как неполный тип, и не может быть использован вместо своих полных собратьев, например, в качестве типа параметра функции.
А ещё есть класс Void, но это уже совсем другая история.
Чтобы не плодить новых ключевых слов, зачастую используют уже существующие, более-менее подходящие по смыслу. Пример тому — дженерики. С их появлением решили использовать два уже имеющихся слова extends и super. Раньше они означали только расширение класса/интерфейса и обращение к родительскому классу, соответственно. Теперь же при обрамлении этих слов в <> компилятор понимает, что они относятся к дженерикам. Например:
в коллекции opapa находятся элементы Object или его супертипы (вышестоящие — родители, прародители и т.д.), а в коллекции opapa2 находятся элементы Object или расширяющие его типы-классы (нижестоящие — наследники).
Пытливый читатель уже заметил, что представленные в примере записи несут в себе вагон и маленькую тележку глубокой осмысленности, чуждой обычным кодерам. Верно, Object — это «Бог» среди классов, выше Бога не может быть никого, а ниже Бога находится абсолютно вся челядь (о чём нам и подсказывает IDE). Посему смысл подобных записей останется за кадром и в умах определённого круга лиц.
assert — слово появилось с версии Java 1.4 и по умолчанию его использование равно его не использованию. Чтобы оно заработало, нужно включить опцию JVM «-ea». Само по себе слово является проверкой выражения:
и в случае ложного результата выдаёт эксепшн:
native — обозначает, что тело метода написано не в божественной Java, а на каком-то другом непрогрессивном языке (Си, Би, плюсЫ, минусЫ, решёткИ и т.д.). При этом мы из джавы можем дёргать данный метод и получать результат. Используется зачастую ленивыми программистами для работы с уже имеющейся внешней компонентой, вместо написания своей, либо для доступа к специфическим возможностям ОС. Пример из JDK:
synchronized — синхронизация метода или блока между тредами, т.е. один тред зашёл внутрь и делает свои дела, пока остальные терпят снаружи.
volatile — брать значение переменной каждый раз из общей памяти, а не из локального процессорного кэша. Зачем? А вот когда ты на wiki прочитал поразившую тебя до глубины души научную статью 5 лет назад про то, что Земля плоская, т.к. её затянуло в Чёрную Дыру и сплющило под воздействием сильной гравитации, то до сих пор её рассказываешь друзьям в неизменном виде по памяти, хотя результаты исследований уже через неделю после выхода были опровергнуты, а статья обновлена. В этом случае volatile заставил бы тебя перед каждой историей другу перечитывать статью на wiki.
transient — не учитывать определённую переменную при сериализации: ни сохранять, ни восстанавливать её, в общем, игнорировать по максимуму.
strictfp — strict floating-point. На разных платформах аппаратное обеспечение может выдавать разную точность при вычислениях, и до Java 1.2 все промежуточные результаты вычислений автоматически приводились в соответствие со стандартами IEEE 754 для одинарной (single, float) или двойной (double) точности во избежание арифметического переполнения (overflow) или недостаточного значения (underflow). Но с версии Java 1.2 промежуточные результаты по умолчанию могут превышать стандартные диапазоны и выдавать максимально возможную точность, что полезно в авиа или науке. Так что если вы хотите не точности, а переносимости между платформами, или вашего заказчика подёргивает от страшных слов overflow & underflow, то смело ставьте перед классом, интерфейсом или методом слово strictfp, тогда все вычисления с плавающей точкой внутри таких методов, будут ограничиваться и приводиться к стандарту IEEE.
Заключение:
С течением времени в джаву добавляются новые ключевые слова, и никто не застрахован от того, что ваши имена переменных в будущей версии окажутся нелегальны. Но разработчики JDK всегда стараются сделать максимальную совместимость с ранее написанными программами, в связи с чем, например, при вводе новых ключевых слов ограничивают области их применения, либо предлагают использовать составные выражения, которые и ранее разработчики не могли бы использовать в качестве имён переменных из-за разделения слов дефисом. Вот некоторые ключевые слова, которые потенциально могут появиться в будущем:
— `package-private` (модификатор уровня доступа, опускающийся на данный момент)
— `public-read` (публично читаемый, приватно записываемый)
— `type-static` (концепция нужна для проекта Valhalla, означает статичность к специализации класса, а не к самому классу)
— `eventually-final` (то же, что сейчас предполагается делать аннотацией `@Stable`)
— `semi-final` (альтернатива `sealed`)
— `exhaustive-switch` (включение проверки полноты switch, т.е. все ли возможные значения в операторе switch были перечислены)
— `enum-class`, `annotation-class`, `record-class` (как более наглядная альтернатива некоторым имеющимся использованиям `enum` and `@interface`)
— `this-class` (для описания литерала класса для текущего класса)
— `this-return` (для маркировки сеттера или метода билдера как возвращающего своего приемника)
А какие ключевые слова Вы хотели бы добавить в язык?
И вопрос на засыпку: справится ли с подстановкой goto в качестве имени переменной всемогущая рефлексия? А в качестве имени класса?
Приложение A. Ключевые слова Java
Следующие 51 ключевое слово являются зарезервированными для использования в языке Java:
| _ | do | instanceof | strictfp* |
| abstract | double | int | super |
| assert | else | interface | switch |
| boolean | enum | long | synchronized |
| break | extends | native | this |
| byte | final | new | throw |
| case | finally | package | throws |
| catch | float | private | transient |
| char | for | protected | try |
| class | goto | public | void |
| const | if | return | volatile |
| continue | implements | short | while |
| default | import | static |
Ключевое слово _ (символ нижнего подчёркивания) – является ключевым словом начиная с Java 9.
Ключевые слова goto и const являются зарезервированными словами C++, но в настоящее время не используются в Java. Это даёт возможность компиляторам Java идентифицировать их и создавать улучшенные сообщения об ошибках, если они появляются в Java программах.
Буквальные значения true, false и null не являются ключевыми словами, это буквальные значения, как например 100. Тем не менее, вы не можете использовать их в качестве идентификаторов, точно также, как вы не можете использовать 100 в качестве идентификатора.
*Ключевое слово strictfp – это модификатор метода или класса, который позволяет им использовать точные вычисления с плавающей точкой. Арифметика с плавающей точкой может выполняться в одном из двух режимов: strict и nonstrict. Режим strict гарантирует, что результат вычисления будет одинаковым во всех реализациях виртуальной машины Java. Режим nonstrict позволяет сохранять промежуточные результаты вычислений в расширенном формате, отличном от стандартного формата чисел с плавающей запятой IEEE. Расширенный формат зависит от машины и позволяет быстрее выполнять код. Однако, когда вы выполняете код с использованием nonstrict режима на разных JVM, вы не всегда можете получить точно такие же результаты. По умолчанию для вычислений с плавающей запятой используется nonstrict режим. Чтобы использовать strict режим в методе или классе, добавьте ключевое слово strictfp в объявление метода или класса. С плавающей запятой strict может дать вам немного лучшую точность, чем nonstrict с плавающей запятой, но различие затронет только некоторые приложения. Точность не наследуется; то есть наличие strictfp в объявлении класса или интерфейса не приводит к тому, что расширенные классы или интерфейсы будут strict.
Какие слова являются зарезервированными словами языка java
[an error occurred while processing this directive]
Программирование на языке Java. Введение в язык Java
[an error occurred while processing this directive](none)
- Hello World
- Шаг за шагом
- Строка 1
- Строка 2
- Строка 3
- Пробелы
- Комментарии
- Зарезервированные ключевые слова
- Идентификаторы
- Литералы
- Целые литералы
- Литералы с плавающей точкой
- Логические литералы
- Символьные литералы
- Строчные литералы
- Операторы
- Разделители
- Переменные
Исходный файл на языке Java—это текстовый файл, содержащий в себе одно или несколько описаний классов. Транслятор Java предполагает, что исходный текст программ хранится в файлах с расширениями Java. Получаемый в процессе трансляции код для каждого класса записывается в отдельном выходном файле, с именем совпадающем с именем класса, и расширением class.
Прежде всего, в этой главе мы напишем, оттранслируем, и запустим каноническую программу «Hello World». После этого мы рассмотрим все существенные лексические элементы, воспринимаемые Java-транслятором: пробелы, комментарии, ключевые слова, идентификаторы, литералы, операторы и разделители. К концу главы вы получите достаточно информации для того чтобы самостоятельно ориентироваться в хорошей Java-программе.
Hello World
Итак, вот ваша первая Java-программа:
Для того, чтобы поработать с приведенными в книге примерами вам нужно получить по сети из Sun Microsystems и установить Java Developers Kit—пакет для разработки Java-приложений (http://java.sun.com/products/jdk).
Язык Java требует, чтобы весь программный код был заключен внутри поименованных классов. Приведенный выше текст примера надо записать в файл HelloWorld.java. Обязательно проверьте соответствие прописных букв в имени файла тому же в названии содержащегося в нем класса. Для того, чтобы оттранслировать этот пример необходимо запустить транслятор Java—javac, указав в качестве параметра имя файла с исходным текстом:
Транслятор создаст файл HelloWorld.class с независимым от процессора байт-кодом нашего примера. Для того, чтобы исполнить полученный код, необходимо иметь среду времени выполнения языка Java (в нашем случае это программа java), в которую надо загрузить новый класс для исполнения. Подчеркнем, что указывается имя класса, а не имя файла, в котором этот класс содержится.
Полезного сделано мало, однако мы убедились, что установленный Java-транслятор и среда времени выполнения работают.
Шаг за шагом
Конечно, HelloWorld—это тривиальный пример. Однако даже такая простая программа новичку в языке Java может показаться пугающе сложной, поскольку она знакомит вас с массой новых понятий и деталей синтаксиса языка Давайте внимательно пройдемся по каждой строке нашего первого примера, анализируя те элементы, из которых состоит Java-программа.
Строка 1
В этой строке использовано зарезервированное слово class. Оно говорит транслятору, что мы собираемся описать новый класс. Полное описание класса располагается между открывающей фигурной скобкой в первой строке и парной ей закрывающей фигурной скобкой в строке 5. Фигурные скобки в Java используются точно так же, как в языках С и С++.
Строка 2
Такая, на первый взгляд, чрезмерно сложная строка примера является следствием важного требования, заложенного при разработке языка Java. Дело в том, что в Java отсутствуют глобальные функции. Поскольку подобные строки будут встречаться в большинстве примеров первой части книги, давайте пристальнее рассмотрим каждый элемент второй строки.
public
Разбивая эту строку на отдельные лексемы, мы сразу сталкиваемся с ключевым словом public. Это—модификатор доступа, который позволяет программисту управлять видимостью любого метода и любой переменной. В данном случае модификатор доступа public означает, что метод main виден и доступен любому классу. Существуют еще 2 указателя уровня доступа—private и protected, с которыми мы более детально познакомимся в главе 8.
static
Следующее ключевое слово—static. С помощью этого слова объявляются методы и переменные класса, используемые для работы с классом в целом. Методы, в объявлении которых использовано ключевое слово static, могут непосредственно работать только с локальными и статическими переменными.
У вас нередко будет возникать потребность в методах, которые возвращают значение того или иного типа: например, int для целых значений, float—для вещественных или имя класса для типов данных, определенных программистом. В нашем случае нужно просто вывести на экран строку, а возвращать значение из метода main не требуется. Именно поэтому и был использован модификатор void. Более детально этот вопрос обсуждается в главе 4.
Наконец, мы добрались до имени метода main. Здесь нет ничего необычного, просто все существующие реализации Java-интерпретаторов, получив команду интерпретировать класс, начинают свою работу с вызова метода main. Java-транслятор может оттранслировать класс, в котором нет метода main. А вот Java-интерпретатор запускать классы без метода main не умеет.
Все параметры, которые нужно передать методу, указываются внутри пары круглых скобок в виде списка элементов, разделенных символами «;» (точка с запятой). Каждый элемент списка параметров состоит из разделенных пробелом типа и идентификатора. Даже если у метода нет параметров, после его имени все равно нужно поставить пару круглых скобок. В примере, который мы сейчас обсуждаем, у метода main только один параметр, правда довольно сложного типа.
Элемент String args[] объявляет параметр с именем args, который является массивом объектов—представителей класса String. Обратите внимание на квадратные скобки, стоящие после идентификатора args. Они говорят о том, что мы имеем дело с массивом, а не с одиночным элементом указанного типа. Мы вернемся к обсуждению массивов в следующей главе, а пока отметим, что тип String—это класс. Более детально о строках мы поговорим в главе 9.
Строка 3
В этой строке выполняется метод println объекта out. Объект out объявлен в классе OutputStream и статически инициализируется в классе System. В главах 9 и 13 у вас будет шанс познакомиться с нюансами работы классов String и OutputStream.
Закрывающей фигурной скобкой в строке 4 заканчивается объявление метода main, а такая же скобка в строке 5 завершает объявление класса HelloWorld.
Лексические основы
Теперь, когда мы подробно рассмотрели минимальный Java-класс, давайте вернемся назад и рассмотрим общие аспекты синтаксиса этого языка. Программы на Java—это набор пробелов, комментариев, ключевых слов, идентификаторов, литеральных констант, операторов и разделителей.
Пробелы
Java—язык, который допускает произвольное форматирование текста программ. Для того, чтобы программа работала нормально, нет никакой необходимости выравнивать ее текст специальным образом. Например, класс HelloWorld можно было записать в двух строках или любым другим способом, который придется вам по душе. И он будет работать точно так же при условии, что между отдельными лексемами (между которыми нет операторов или разделителей) имеется по крайней мере по одному пробелу, символу табуляции или символу перевода строки.
Комментарии
Хотя комментарии никак не влияют на исполняемый код программы, при правильном использовании они оказываются весьма существенной частью исходного текста. Существует три разновидности комментариев: комментарии в одной строке, комментарии в нескольких строках и, наконец, комментарии для документирования. Комментарии, занимающие одну строку, начинаются с символов // и заканчиваются в конце строки. Такой стиль комментирования полезен для размещения кратких пояснений к отдельным строкам кода:
Для более подробных пояснений вы можете воспользоваться комментариями, размещенными на нескольких строках, начав текст комментариев символами /* и закончив символами */ При этом весь текст между этими парами символов будет расценен как комментарий и транслятор его проигнорирует.
Третья, особая форма комментариев, предназначена для сервисной программы javadoc, которая использует компоненты Java-транслятора для автоматической генерации документации по интерфейсам классов. Соглашение, используемое для комментариев этого вида, таково: для того, чтобы разместить перед объявлением открытого (public) класса, метода или переменной документирующий комментарий, нужно начать его с символов /** (косая черта и две звездочки). Заканчивается такой комментарий точно так же, как и обычный комментарий—символами */. Программа javadoc умеет различать в документирующих комментариях некоторые специальные переменные, имена которых начинаются с символа @. Вот пример такого комментария:
Зарезервированные ключевые слова
Зарезервированные ключевые слова—это специальные идентификаторы, которые в языке Java используются для того, чтобы идентифицировать встроенные типы, модификаторы и средства управления выполнением программы. На сегодняшний день в языке Java имеется 59 зарезервированных слов (см. таблицу 2). Эти ключевые слова совместно с синтаксисом операторов и разделителей входят в описание языка Java. Они могут применяться только по назначению, их нельзя использовать в качестве идентификаторов для имен переменных, классов или методов.
abstract boolean break byte byvalue case cast catch char class const continue default do double else extends false final finally float for future generic goto if implements import inner instanceof int interface long native new null operator outer package private protected public rest return short static super switch syncronized this throw throws transient true try var void volatile while Отметим, что слова byvalue, cast, const, future, generic, goto, inner, operator, outer, rest, var зарезервированы в Java, но пока не используются Кроме этого, в Java есть зарезервированные имена методов (эти методы наследуются каждым классом, их нельзя использовать, за исключением случаев явного переопределения методов класса Object).
clone equals finalize getClass hashCode notify notifyAll toString wait Идентификаторы
Идентификаторы используются для именования классов, методов и переменных. В качестве идентификатора может использоваться любая последовательность строчных и прописных букв, цифр и символов _ (подчеркивание) и $ (доллар). Идентификаторы не должны начинаться с цифры, чтобы транслятор не перепутал их с числовыми литеральными константами, которые будут описаны ниже. Java—язык, чувствительный к регистру букв. Это означает, что, к примеру, Value и VALUE—различные идентификаторы.
Литералы
Константы в Java задаются их литеральным представлением. Целые числа, числа с плавающей точкой, логические значения, символы и строки можно располагать в любом месте исходного кода. Типы будут рассмотрены в главе 4.
Целые литералы
Целые числа—это тип, используемый в обычных программах наиболее часто. Любое целочисленное значение, например, 1, 2, 3, 42—это целый литерал. В данном примере приведены десятичные числа, то есть числа с основанием 10—именно те, которые мы повседневно используем вне мира компьютеров. Кроме десятичных, в качестве целых литералов могут использоваться также числа с основанием 8 и 16—восьмеричные и шестнадцатиричные. Java распознает восьмеричные числа по стоящему впереди нулю. Нормальные десятичные числа не могут начинаться с нуля, так что использование в программе внешне допустимого числа 09 приведет к сообщению об ошибке при трансляции, поскольку 9 не входит в диапазон 0.. 7, допустимый для знаков восьмеричного числа. Шестнадцатиричная константа различается по стоящим впереди символам нуль-х (0х или 0Х). Диапазон значений шестнадцатиричной цифры—0.. 15, причем в качестве цифр для значений 10.. 15 используются буквы от А до F (или от а до f). С помощью шестнадцатиричных чисел вы можете в краткой и ясной форме представить значения, ориентированные на использование в компьютере, например, написав Oxffff вместо 65535.
Целые литералы являются значениями типа int, которое в Java хранится в 32-битовом слове. Если вам требуется значение, которое по модулю больше, чем приблизительно 2 миллиарда, необходимо воспользоваться константой типа long. При этом число будет храниться в 64-битовом слове. К числам с любым из названных выше оснований вы можете приписать справа строчную или прописную букву L, указав таким образом, что данное число относится к типу long. Например, Ox7ffffffffffffffL или 9223372036854775807L—это значение, наибольшее для числа типа long.
Литералы с плавающей точкой
Числа с плавающей точкой представляют десятичные значения, у которых есть дробная часть. Их можно записывать либо в обычном, либо экспоненциальном форматах. В обычном формате число состоит из некоторого количества десятичных цифр, стоящей после них десятичной точки, и следующих за ней десятичных цифр дробной части. Например, 2.0, 3.14159 и .6667—это допустимые значения чисел с плавающей точкой, записанных в стандартном формате. В экспоненциальном формате после перечисленных элементов дополнительно указывается десятичный порядок. Порядок определяется положительным или отрицательным десятичным числом, следующим за символом Е или е. Примеры чисел в экспоненциальном формате: 6.022е23, 314159Е-05, 2е+100. В Java числа с плавающей точкой по умолчанию рассматриваются, как значения типа double. Если вам требуется константа типа float, справа к литералу надо приписать символ F или f. Если вы любитель избыточных определений—можете добавлять к литералам типа double символ D или d. Значения используемого по умолчанию типа double хранятся в 64-битовом слове, менее точные значения типа float—в 32-битовых.
Логические литералы
У логической переменной может быть лишь два значения—true (истина) и false (ложь). Логические значения true и false не преобразуются ни в какое числовое представление. Ключевое слово true в Java не равно 1, a false не равно 0. В Java эти значения могут присваиваться только переменным типа boolean либо использоваться в выражениях с логическими операторами.
Символьные литералы
Символы в Java—это индексы в таблице символов UNICODE. Они представляют собой 16-битовые значения, которые можно преобразовать в целые числа и к которым можно применять операторы целочисленной арифметики, например, операторы сложения и вычитания. Символьные литералы помещаются внутри пары апострофов (‘ ‘). Все видимые символы таблицы ASCII можно прямо вставлять внутрь пары апострофов:—’a’, ‘z’, ‘@’. Для символов, которые невозможно ввести непосредственно, предусмотрено несколько управляющих последовательностей.
Управляющая последовательность Описание \ddd Восьмеричный символ (ddd) \uxxxx Шестнадцатиричный символ UNICODE (xxxx) \’ Апостроф \» Кавычка \\ Обратная косая черта \r Возврат каретки (carriage return) \n Перевод строки (line feed, new line) \f Перевод страницы (form feed) \t Горизонтальная табуляция (tab) \b Возврат на шаг (backspace) Строчные литералы
Строчные литералы в Java выглядят точно также, как и во многих других языках—это произвольный текст, заключенный в пару двойных кавычек («»). Хотя строчные литералы в Java реализованы весьма своеобразно (Java создает объект для каждой строки), внешне это никак не проявляется. Примеры строчных литералов: «Hello World!»; «две\строки; \ А это в кавычках\»». Все управляющие последовательности и восьмеричные / шестнадцатиричные формы записи, которые определены для символьных литералов, работают точно так же и в строках. Строчные литералы в Java должны начинаться и заканчиваться в одной и той же строке исходного кода. В этом языке, в отличие от многих других, нет управляющей последовательности для продолжения строкового литерала на новой строке.
Операторы
Оператор—это нечто, выполняющее некоторое действие над одним или двумя аргументами и выдающее результат. Синтаксически операторы чаще всего размещаются между идентификаторами и литералами. Детально операторы будут рассмотрены в главе 5, их перечень приведен в таблице 3. 3.
Разделители
Лишь несколько групп символов, которые могут появляться в синтаксически правильной Java-программе, все еще остались неназваннами. Это—простые разделители, которые влияют на внешний вид и функциональность программного кода.
Переменные
Переменная—это основной элемент хранения информации в Java-программе. Переменная характеризуется комбинацией идентификатора, типа и области действия. В зависимости от того, где вы объявили переменную, она может быть локальной, например, для кода внутри цикла for, либо это может быть переменная экземпляра класса, доступная всем методам данного класса. Локальные области действия объявляются с помощью фигурных скобок.
Объявление переменной
Основная форма объявления переменной такова:
Тип—это либо один из встроенных типов, то есть, byte, short, int, long, char, float, double, boolean, либо имя класса или интерфейса. Мы подробно обсудим все эти типы в следующей главе. Ниже приведено несколько примеров объявления переменных различных типов. Обратите внимание на то, что некоторые примеры включают в себя инициализацию начального значения. Переменные, для которых начальные значения не указаны, автоматически инициализируются нулем.
Объявляет три целых переменных а, b, с.
Объявляет еще три целых переменных, инициализирует d и f.
Инициализирует z. double pi = 3. 14159;
Объявляет число пи (не очень точное, но все таки пи).
Переменная х получает значение ‘х’.
В приведенном ниже примере создаются три переменные, соответствующие сторонам прямоугольного треугольника, а затем c помощью теоремы Пифагора вычисляется длина гипотенузы, в данном случае числа 5, величины гипотенузы классического прямоугольного треугольника со сторонами 3-4-5.
Ваш первый шаг
Мы уже многого достигли: сначала написали небольшую программу на языке Java и подробно рассмотрели, из чего она состоит (блоки кода, комментарии). Мы познакомились со списком ключевых слов и операторов, чье назначение будет подробно объяснено в дальнейших главах. Теперь вы в состоянии самостоятельно различать основные части любой Java-программы и готовы к тому, чтобы приступить к чтению главы 4, в которой подробно рассматриваются простые типы данных.