Читать онлайн «Программирование на Java». Страница 21

-21 << 27 = 01011000000000000000000000000000 = 1476395008

-21 << 28 = 10110000000000000000000000000000 = -1342177280

-21 << 29 = 01100000000000000000000000000000 = 1610612736

-21 << 30 = 11000000000000000000000000000000 = -1073741824

-21 << 31 = 10000000000000000000000000000000 = -2147483648

Как видно из примера, неожиданности возникают тогда, когда значащие биты начинают занимать первую позицию и влиять на знак результата.

При сдвиге вправо все биты аргумента смещаются на указанное количество позиций, соответственно, вправо. Однако встает вопрос – каким значением заполнять освобождающиеся позиции слева, в том числе и отвечающую за знак. Есть два варианта. Оператор >> использует для заполнения этих позиций значение знакового бита, то есть результат всегда имеет тот же знак, что и начальное значение. Второй оператор >>> заполняет их нулями, то есть результат всегда положительный.

// Сдвиг вправо для положительного числа 20

// Оператор >>

20 >> 00 = 00000000000000000000000000010100 = 20

20 >> 01 = 00000000000000000000000000001010 = 10

20 >> 02 = 00000000000000000000000000000101 = 5

20 >> 03 = 00000000000000000000000000000010 = 2

20 >> 04 = 00000000000000000000000000000001 = 1

20 >> 05 = 00000000000000000000000000000000 = 0

// Оператор >>>

20 >>> 00 = 00000000000000000000000000010100 = 20

20 >>> 01 = 00000000000000000000000000001010 = 10

20 >>> 02 = 00000000000000000000000000000101 = 5

20 >>> 03 = 00000000000000000000000000000010 = 2

20 >>> 04 = 00000000000000000000000000000001 = 1

20 >>> 05 = 00000000000000000000000000000000 = 0

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

// Сдвиг вправо для отрицательного числа -21

// Оператор >>

-21 >> 00 = 11111111111111111111111111101011 = -21

-21 >> 01 = 11111111111111111111111111110101 = -11

-21 >> 02 = 11111111111111111111111111111010 = -6

-21 >> 03 = 11111111111111111111111111111101 = -3

-21 >> 04 = 11111111111111111111111111111110 = -2

-21 >> 05 = 11111111111111111111111111111111 = -1

// Оператор >>>

-21 >>> 00 = 11111111111111111111111111101011 = -21

-21 >>> 01 = 01111111111111111111111111110101 = 2147483637

-21 >>> 02 = 00111111111111111111111111111010 = 1073741818

-21 >>> 03 = 00011111111111111111111111111101 = 536870909

-21 >>> 04 = 00001111111111111111111111111110 = 268435454

-21 >>> 05 = 00000111111111111111111111111111 = 134217727

...

-21 >>> 24 = 00000000000000000000000011111111 = 255

-21 >>> 25 = 00000000000000000000000001111111 = 127

-21 >>> 26 = 00000000000000000000000000111111 = 63

-21 >>> 27 = 00000000000000000000000000011111 = 31

-21 >>> 28 = 00000000000000000000000000001111 = 15

-21 >>> 29 = 00000000000000000000000000000111 = 7

-21 >>> 30 = 00000000000000000000000000000011 = 3

-21 >>> 31 = 00000000000000000000000000000001 = 1

Как видно из примеров, эти операции аналогичны делению на 2n. Причем, если для положительных аргументов с ростом n результат закономерно стремится к 0, то для отрицательных предельным значением является -1.

Заключение

В этой лекции были рассмотрены основы лексического анализа программ Java. Для их записи применяется универсальная кодировка Unicode, позволяющая использовать любой язык помимо традиционного английского. Еще раз напомним, что использование Unicode возможно и необходимо в следующих конструкциях:

* комментарии;

* идентификаторы ;

* символьные и строковые литералы.

Остальные же ( пробелы, ключевые слова, числовые, булевские и null- литералы, разделители и операторы) легко записываются с применением лишь ASCII -символов. В то же время любой Unicode -символ также можно задать в виде специальной последовательности ASCII -символов.

Во время анализа компилятор выделяет из текста программы < пробелы > (были рассмотрены все символы, которые рассматриваются как пробелы ) и комментарии, которые полностью удаляются из кода (были рассмотрены все виды комментариев, в частности комментарий разработчика). Пробелы и все виды комментариев служат для разбиения текста программы на лексемы. Были рассмотрены все виды лексем, в том числе все виды литералов.

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

Типы данных определяют основные возможности любого языка. Кроме того, Java является строго типизированным языком, а потому четкое понимание модели типов данных очень помогает в написании качественных программ. Лекция начинается с введения понятия переменной, на примере которой иллюстрируются особенности применения типов в Java. Описывается разделение всех типов на простейшие и ссылочные, операции над значениями различных типов, а также особый класс Class, который играет роль метакласса в Java.

Введение

Java является строго типизированным языком. Это означает, что любая переменная и любое выражение имеют известный тип еще на момент компиляции. Такое строгое правило позволяет выявлять многие ошибки уже во время компиляции. Компилятор, найдя ошибку, указывает точное место (строку) и причину ее возникновения, а динамические "баги" (от английского bugs) необходимо сначала выявить с помощью тестирования (что может потребовать значительных усилий), а затем найти место в коде, которое их породило. Поэтому четкое понимание модели типов данных в Java очень помогает в написании качественных программ.

Все типы данных разделяются на две группы. Первую составляют 8 простых, или примитивных (от английского primitive), типов данных. Они подразделяются на три подгруппы:

* целочисленные

- byte

- short

- int

- long

- char (также является целочисленным типом)

* дробные

- float

- double

* булевые

- boolean

Вторую группу составляют объектные, или ссылочные (от английского reference), типы данных. Это все классы, интерфейсы и массивы. В стандартных библиотеках первых версий Java находилось несколько сот классов и интерфейсов, сейчас их уже тысячи. Кроме стандартных, написаны многие и многие классы и интерфейсы, составляющие любую Java-программу.

Иллюстрировать логику работы с типами данных проще всего на примере переменных.

Переменные

Переменные используются в программе для хранения данных. Любая переменная имеет три базовых характеристики:

* имя;

* тип;

* значение.

Имя уникально идентифицирует переменную и позволяет обращаться к ней в программе. Тип описывает, какие величины может хранить переменная. Значение – текущая величина, хранящаяся в переменной на данный момент.

Работа с переменной всегда начинается с ее объявления (declaration). Конечно, оно должно включать в себя имя объявляемой переменной. Как было сказано, в Java любая переменная имеет строгий тип, который также задается при объявлении и никогда не меняется. Значение может быть указано сразу (это называется инициализацией), а в большинстве случаев задание начальной величины можно и отложить.

Некоторые примеры объявления переменных примитивного типа int с инициализаторами и без таковых:

int a;

int b = 0, c = 3+2;

int d = b+c;

int e = a = 5;

Из примеров видно, что инициализатором может быть не только константа, но и арифметическое выражение. Иногда это выражение может быть вычислено во время компиляции (такое как 3+2 ), тогда компилятор сразу записывает результат. Иногда это действие откладывается на момент выполнения программы (например, b+c ). В последнем случае нескольким переменным присваивается одно и то же значение, однако объявляется лишь первая из них (в данном примере е ), остальные уже должны существовать.

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

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

Кроме того, при объявлении переменной может быть использовано ключевое слово final. Его указывают перед типом переменной, и тогда ее необходимо сразу инициализировать и уже больше никогда не менять ее значение. Таким образом, final -переменные становятся чем-то вроде констант, но на самом деле некоторые инициализаторы могут вычисляться только во время исполнения программы, генерируя различные значения.

Простейший пример объявления final -переменной:

final double pi=3.1415;

Примитивные и ссылочные типы данных

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

Возьмем простой тип int: