Встроенные типы данных, операции над ними
Приступая Рє изучению РЅРѕРІРѕРіРѕ языка, полезно поинтересоваться, какие исходные данные РјРѕРіСѓС‚ обрабатываться средствами этого языка, РІ каком РІРёРґРµ РёС… можно задавать Рё какие стандартные средства обработки данных заложены РІ язык. Рто довольно скучное занятие, поскольку РІ каждом развитом языке программирования множество типов данных Рё еще больше правил РёС… использования. Однако несоблюдение этих правил РїСЂРёРІРѕРґРёС‚ Рє появлению скрытых ошибок, обнаружить которые РёРЅРѕРіРґР° бывает очень трудно. РќСѓ что же, РІ каждом ремесле приходится сначала "играть гаммы", РЅРµ можем РѕС‚ этого уйти Рё РјС‹.
Р’СЃРµ правила языка Java исчерпывающе изложены РІ его спецификации, сокращенно называемой JLS (Java Language Specification), местоположение которой указано РІРѕ введении. РРЅРѕРіРґР°, чтобы понять, как выполняется та или иная конструкция языка Java, приходится обращаться Рє спецификации, РЅРѕ, Рє счастью, это бывает редко: правила языка Java достаточно просты Рё естественны.
В этой главе перечислены примитивные типы данных, операции над ними, операторы управления и показаны "подводные камни", которых следует избегать при их использовании. Но начнем, по традиции, с простейшей программы.
Первая программа на Java
По давней традиции, восходящей к языку С, учебники по языкам программирования начинаются с программы "Hello, World!". Не будем нарушать эту традицию. В листинге 1.1 приведена подобная программа. Она написана в самом простом виде, какой только возможен на языке Java.
Листинг 1.1. Первая программа на языке Java
class HelloWorld{
public static void main(String[] args){
System.out.println("Hello, XXI Century World!");
}
Вот и все, только пять строчек! Но даже на этом простом примере можно заметить целый ряд существенных особенностей языка Java.
□ Всякая программа, написанная на языке Java, представляет собой один или несколько классов, в этом простейшем примере только один класс (class).
□ Начало класса отмечается служебным словом class, за которым следует имя класса, выбираемое произвольно, в данном случае это имя HelloWorld. Все, что содержится в классе, записывается в фигурных скобках и составляет тело класса (class body).
□ Все действия в программе производятся с помощью методов обработки информации, коротко говорят просто метод (method). Методы используются в объектноориентированных языках вместо функций, применяемых в процедурных языках.
□ Методы различаются по именам и параметрам. Один из методов обязательно должен называться main, с него начинается выполнение программы. В нашей простейшей программе только один метод, а значит, имя его main.
□ Как и положено функции, метод всегда выдает в результате (чаще говорят возвращает (returns)) только одно значение, тип которого обязательно указывается перед именем метода. Метод может и не возвращать никакого значения, играя роль процедуры. Так и есть в нашем случае. Тогда вместо типа возвращаемого значения записывается слово void, как это и сделано в примере.
в–Ў После имени метода РІ скобках через запятую перечисляются параметры (parameters) метода. Для каждого параметра указывается его тип Рё, через пробел, РёРјСЏ. РЈ метода main () только РѕРґРёРЅ параметр, его тип — массив, состоящий РёР· строк символов. Строка символов — это встроенный РІ Java API тип String, Р° квадратные СЃРєРѕР±РєРё — признак массива. РРјСЏ параметра может быть произвольным, РІ примере выбрано РёРјСЏ args.
□ Перед типом возвращаемого методом значения могут быть записаны модификаторы (modifiers). В примере их два: слово public означает, что этот метод доступен отовсюду; слово static обеспечивает возможность вызова метода main() в самом начале выполнения программы. Модификаторы, вообще говоря, необязательны, но для метода main() они необходимы.
Замечание
В тексте этой книги после имени метода ставятся скобки, чтобы подчеркнуть, что это имя метода, а не простой переменной.
□ Все, что содержит метод, тело метода (method body), записывается в фигурных скобках.
Единственное действие, которое выполняет метод main () в нашем примере, заключается в вызове другого метода со сложным именем System.out.println и передаче ему на обработку одного аргумента — текстовой константы "Hello, xxi Century World!". Текстовые константы записываются в кавычках, которые являются только ограничителями и не входят в текст.
Составное имя System.out.println означает, что в классе System, входящем в Java API, определяется переменная с именем out, содержащая экземпляр одного из классов Java API, класса PrintStream, в котором есть метод println (). Все это станет ясно позднее, а пока просто будем писать это длинное имя.
Действие метода println() заключается в выводе заданного ему аргумента в выходной поток, связанный обычно с выводом на экран текстового терминала, в окно MS-DOS Prompt, Command Prompt или Xterm в зависимости от вашей системы. После вывода курсор переходит на начало следующей строки экрана, на что указывает окончание ln, само слово println — сокращение слов print line. В составе Java API есть и метод print (), оставляющий курсор в конце выведенной строки. Разумеется, это прямое влияние языка Pascal.
Сильное влияние языка С привело к появлению в Java SE 5 (Java Standard Edition) метода System.out.printf(), очень похожего на одноименную функцию языка С. Мы подробно опишем этот метод в главе 23, но желающие могут ознакомиться с ним прямо сейчас.
Сделаем сразу важное замечание. Язык Java различает строчные и прописные буквы, имена main, Main, main различны с "точки зрения" компилятора Java. В примере важно писать String, System с заглавной буквы, а main — со строчной. Но внутри текстовой константы неважно, писать Century или century, компилятор вообще не "смотрит" на текст в кавычках, разница будет видна только на экране.
Замечание
Язык Java различает прописные и строчные буквы.
В именах нельзя оставлять пробелы. Свои имена можно записывать как угодно, можно было бы дать классу имя helloworld или helloWorld, но между Java-программистами заключено соглашение, называемое "Code Conventions for the Java Programming Language", хранящееся по адресу . Вот несколько пунктов этого соглашения:
□ имена классов начинаются с прописной (заглавной) буквы; если имя содержит несколько слов, то каждое слово начинается с прописной буквы;
□ имена методов и переменных начинаются со строчной буквы; если имя содержит несколько слов, то каждое следующее слово начинается с прописной буквы;
□ имена констант записываются полностью прописными буквами; если имя состоит из нескольких слов, то между ними ставится знак подчеркивания.
Конечно, эти правила необязательны, хотя они и входят в JLS, п. 6.8, но сильно облегчают понимание кода и придают программе характерный для Java стиль.
Стиль определяют не только имена, но и размещение текста программы по строкам, например расположение фигурных скобок: оставлять ли открывающую фигурную скобку в конце строки с заголовком класса или метода или переносить на следующую строку? Почему-то этот пустячный вопрос вызывает ожесточенные споры, некоторые средства разработки даже предлагают выбрать определенный стиль расстановки фигурных скобок. Многие фирмы устанавливают свой внутрифирменный стиль. В книге мы постараемся следовать стилю "Code Conventions" и в том, что касается разбиения текста программы на строки (компилятор же рассматривает всю программу как одну длинную строку, для него программа — это просто последовательность символов), и в том, что касается отступов (indent) в тексте.
Ртак, программа написана РІ каком-либо текстовом редакторе, например РІ Блокноте (Notepad), emacs или vi. Теперь ее надо сохранить РІ файле РІ текстовом, РЅРѕ РЅРµ РІ графическом формате. РРјСЏ файла должно РІ точности совпадать СЃ именем класса, содержащего метод main (). Данное правило очень желательно выполнять. РџСЂРё этом система исполнения Java будет быстро находить метод main () для начала работы, просто отыскивая класс, совпадающий СЃ именем файла. Расширение имени файла должно быть java.
Совет
Называйте файл с программой именем класса, содержащего метод main(), соблюдая регистр букв.
В нашем примере сохраним программу в файле с именем HelloWorldjava в текущем каталоге. Затем вызовем компилятор, передавая ему имя файла в качестве аргумента:
javac HelloWorld.java
Компилятор создаст файл с байт-кодами, даст ему имя HelloWorld.class и запишет этот файл в текущий каталог.
Осталось вызвать интерпретатор байт-кодов, передав ему в качестве аргумента имя класса (а не файла!):
java HelloWorld
На экране появится строка:
Hello, XXI Century World!
Замечание
Не указывайте расширение class при вызове интерпретатора.
На рис. 1.1 показано, как все это выглядит в окне Command Prompt операционной системы MS Windows 2003.
|
| Р РёСЃ. 1.1. РћРєРЅРѕ Command Prompt |
При работе в какой-либо интегрированной среде, например Eclipse или NetBeans, все эти действия вызываются выбором соответствующих пунктов меню или "горячими" клавишами — единых правил здесь нет.
Комментарии
В текст программы можно вставить комментарии, которые компилятор не будет учитывать. Они очень полезны для пояснений по ходу программы. В период отладки можно выключать из действий один или несколько операторов, пометив их символами комментария, как говорят программисты, "закомментировав" их. Кроме того, некоторые программы, работающие с Java, извлекают из комментариев полезные для себя сведения.
Комментарии вводятся таким образом:
□ за двумя наклонными чертами, написанными подряд //, без пробела между ними, начинается комментарий, продолжающийся до конца строки;
□ за наклонной чертой и звездочкой /* начинается комментарий, который может занимать несколько строк, до звездочки и наклонной черты */ (без пробелов между этими знаками);
в–Ў Р·Р° наклонной чертой Рё РґРІСѓРјСЏ звездочками /** начинается комментарий, который может занимать несколько строк, РґРѕ звездочки Рё наклонной черты */. РР· таких комментариев формируется документация.
Комментарии очень удобны для чтения и понимания кода, они превращают программу в документ, описывающий ее действия. Программу с хорошими комментариями называют самодокументированной. Поэтому в Java и введены комментарии третьего типа, а в состав JDK включена утилита — программа j avadoc, извлекающая эти комментарии в отдельные файлы формата HTML и создающая гиперссылки между ними. В такой комментарий кроме собственно комментария можно вставить указания программе javadoc, которые начинаются с символа @.
Рменно так создается документация Рє JDK.
Добавим комментарии к нашему примеру (листинг 1.2).
Листинг 1.2. Первая программа с комментариями
/**
* Разъяснение содержания и особенностей программы...
* @author РРјСЏ Фамилия (автора)
* @version 1.0 (это версия программы)
*/
class HelloWorld{ // HelloWorld — это только имя // Следующий метод начинает выполнение программы
public static void main(String[] args){ // args не используются /* Следующий метод просто выводит свой аргумент * на экран дисплея */
System.out.println("Hello, XXI РЎentury World!");
// Следующий вызов закомментирован,
// метод не будет выполняться
// System.out.println("Farewell, XX РЎentury!");
}
}
Звездочки в начале строк не имеют никакого значения, они написаны просто для выделения комментария. Пример, конечно, перегружен пояснениями (это плохой стиль), здесь просто показаны разные формы комментариев.
Аннотации
Обратите внимание на комментарий, приведенный в начале листинга 1.2. В него вставлены указания-теги @author и @version утилите javadoc. Просматривая текст этого комментария и встретив какой-либо из тегов, утилита javadoc выполнит предписанные тегом действия. Например, тег @see предписывает сформировать гиперссылку на другой документ HTML, а тег @deprecated, записанный в комментарий перед методом, вызовет пометку этого метода в документации как устаревшего.
Рдея давать утилите предписания СЃ помощью тегов оказалась весьма плодотворной. РљСЂРѕРјРµ javadoc были написаны РґСЂСѓРіРёРµ утилиты Рё целые программные продукты, которые РІРІРѕРґСЏС‚ новые теги Рё используют РёС… для СЃРІРѕРёС… целей. Например, программа XDoclet может автоматически создавать различные конфигурационные файлы, необходимые для работы сложных приложений. Разработчику достаточно вставить РІ СЃРІРѕСЋ программу комментарии РІРёРґР° /**...*/ СЃ тегами специального РІРёРґР° Рё запустить утилиту Xdoclet, которая сгенерирует РІСЃРµ необходимые файлы.
Рспользование таких утилит стало общепризнанной практикой, Рё, начиная СЃ пятой версии Java SE, было решено ввести РїСЂСЏРјРѕ РІ компилятор возможность обрабатывать теги, которые получили название аннотаций. Аннотации записываются РЅРµ внутри комментариев РІРёРґР° /**...*/, Р° непосредственно РІ том месте, РіРґРµ РѕРЅРё нужны. Например, после того как РјС‹ запишем непосредственно перед заголовком какого-либо метода аннотацию @Deprecated, компилятор будет выводить РЅР° консоль предупреждение Рѕ том, что этот метод устарел Рё следует воспользоваться РґСЂСѓРіРёРј методом. Обычно замена указывается тут же, РІ этом же комментарии.
Несколько аннотаций, количество которых увеличивается СЃ каждой РЅРѕРІРѕР№ версией JDK, объявлено РїСЂСЏРјРѕ РІ компиляторе. РРјРё можно пользоваться без дополнительных усилий. РњС‹ будем вводить РёС… РїРѕ мере надобности. РљСЂРѕРјРµ РЅРёС… разработчик может объявить Рё использовать РІ своем приложении СЃРІРѕРё аннотации. Как это делается, рассказано РІ главе 3.
Константы
В языке Java можно записывать константы различных типов в разных видах. Форма записи констант почти полностью заимствована из языка С. Перечислим все разновидности констант.
Целые
Целые константы можно записывать в четырех системах счисления:
□ в привычной для нас десятичной форме: +5, -7, 12345678;
□ в двоичной форме, начиная с нуля и латинской буквы b или b: 0b1001, 0B11011;
□ в восьмеричной форме, начиная с нуля: 027, -0326, 0777 (в записи таких констант недопустимы цифры 8 и 9);
ЗАмЕчАниЕ
Целое число, начинающееся с нуля, трактуется как записанное в восьмеричной форме, а не в десятичной.
□ в шестнадцатеричной форме, начиная с нуля и латинской буквы x или x: 0xff0a, 0xFC2D, 0X45a8, 0X77FF (здесь строчные и прописные буквы не различаются).
Для улучшения читаемости группы цифр в числе можно разделять знаком подчеркивания: 1_001_234, 0xFC_2D.
Целые константы хранятся в оперативной памяти в формате типа int (см. далее).
В конце целой константы можно записать латинскую букву "L" (прописную L или строчную l), тогда константа будет сохраняться в длинном формате типа long (см. далее): +25L, -037l, 0xffL, 0XDFDFl.
Совет
Не используйте при записи длинных целых констант строчную латинскую букву l, ее легко спутать с единицей.
Действительные
Действительные константы записываются только в десятичной системе счисления в двух формах:
□ с фиксированной точкой: 37.25, -128.678967, +27.035;
□ с плавающей точкой: 2.5e34, -0.345e-25, 37.2E+4; можно писать строчную или прописную латинскую букву E; пробелы и скобки недопустимы.
В конце действительной константы можно поставить букву F или f, тогда константа будет сохраняться в оперативной памяти в формате типа float (см. далее): 3.5f, -4 5.67F, 4.7e-5f. Можно приписать и букву D (или d): 0.04 5D, -456.77889d, означающую тип double, но это излишне, поскольку действительные константы и так хранятся в формате типа double.
Символы
Одиночные символы записываются в апострофах, чтобы отличить их от имен переменных. Для записи символов используются следующие формы:
□ печатные символы, записанные на клавиатуре, просто записываются в апострофах (одинарных кавычках): 'a', 'N', '?';
□ управляющие и специальные символы записываются в апострофах с обратной наклонной чертой, чтобы отличить их от обычных символов:
• '\n' — символ перевода строки LF (Line Feed) с кодом ASCII 10;
• '\r' — символ возврата каретки CR (Carriage Return) с кодом 13;
• '\f' — символ перевода страницы FF (Form Feed) с кодом 12;
• ' \b' — символ возврата на шаг BS (Backspace) с кодом 8;
• '\t' — символ горизонтальной табуляции HT (Horizontal Tabulation) с кодом 9;
• '\\' — обратная наклонная черта;
• 'Vм — кавычка;
• '\'' — апостроф;
□ код любого символа с десятичной кодировкой от 0 до 255 можно задать, записав его не более чем тремя цифрами в восьмеричной системе счисления в апострофах после обратной наклонной черты: '\123' — буква S, '\346' — буква ж в кодировке CP1251. Нет смысла использовать эту форму записи для печатных и управляющих символов, перечисленных в предыдущем пункте, поскольку компилятор сразу же переведет восьмеричную запись в указанную ранее форму. Наибольший восьмеричный код ' \377' — десятичное число 255;
□ код любого символа в кодировке Unicode набирается в апострофах после обратной наклонной черты и латинской буквы u четырьмя шестнадцатеричными цифрами:
'\u0053' — буква S, ' \u0416' — буква ж.
Символы хранятся в формате типа char (см. далее).
Примечание
Прописные русские буквы в кодировке Unicode занимают диапазон от '\u0410' — заглавная буква А, до ' \u042F' — заглавная Я, строчные буквы от '\u0430' — а, до ' \u044F' — я.
В какой бы форме ни записывались символы, компилятор переводит их в Unicode, включая и исходный текст программы.
Замечание
Компилятор и исполняющая система Java работают только с кодировкой Unicode.
Строки
Строки символов заключаются в кавычки. Управляющие символы и коды записываются в строках точно так же, с обратной наклонной чертой, но, разумеется, без апострофов, и оказывают то же действие. Строки могут располагаться только на одной строке исходного кода, нельзя открывающую кавычку поставить на одной строке, а закрывающую — на следующей.
Вот некоторые примеры:
"Рто строка\РїСЃ переносом"
"\"Зубило\" — Чемпион!"
Замечание
Строки символов нельзя начинать на одной строке исходного кода, а заканчивать на другой. Для строковых констант определена операция сцепления, обозначаемая плюсом. Запись
"Сцепление " + "строк"
дает в результате строку "Сцепление строк". Обратите внимание на то, что между сцепляемыми строками не вставлены никакие дополнительные символы. Пробел между ними принадлежал первой строке.
Чтобы записать длинную строку в виде одной строковой константы, надо после закрывающей кавычки на первой и следующих строках поставить плюс (+); тогда компилятор соберет две (или более) строки в одну строковую константу, например:
"Одна строковая константа, записанная " +
"на двух строках исходного текста"
Тот, кто попытается выводить символы в кодировке Unicode, например слово "Россия":
System.out.println("\u0429\u043e\u0441\u0441\u0438\u044f");
должен знать, что MS Windows использует для вывода в окно Command Prompt шрифт Terminal, в котором буквы кириллицы расположены в начальных кодах Unicode (почему-то в кодировке CP866) и разбросаны по другим сегментам Unicode.
Не все шрифты Unicode содержат начертания (glyphs) всех символов, поэтому будьте осторожны при выводе строк в кодировке Unicode.
СОВЕТ
Рспользуйте Unicode напрямую только РІ крайних случаях.
Рмена
Рмена (names) переменных, классов, методов Рё РґСЂСѓРіРёС… объектов РјРѕРіСѓС‚ быть простыми (общее название — идентификаторы (identifiers)) Рё составными (qualified names). Рдентификаторы РІ Java составляются РёР· так называемых Р±СѓРєРІ Java (Java letters) Рё арабских цифр 0—9, причем первым символом идентификатора РЅРµ может быть цифра. (Действительно, как понять запись 2e3: как число 2000,0 или как РёРјСЏ переменной?) Р’ набор Р±СѓРєРІ Java обязательно РІС…РѕРґСЏС‚ прописные Рё строчные латинские Р±СѓРєРІС‹, знак доллара ($) Рё знак подчеркивания (_), Р° также символы национальных алфавитов.
ЗАмЕчАниЕ
Не указывайте в именах знак доллара. Компилятор Java использует его для записи имен вложенных классов.
Вот примеры правильных идентификаторов:
a1 my var var3 5 var veryLongVarName
aName theName a2Vh36kBnMt456dX
В именах лучше не использовать строчную букву l, которую легко спутать с единицей, и букву о, которую легко принять за нуль.
Придумывая имена, не забывайте о рекомендациях "Code Conventions".
В классе Character, входящем в состав Java API, есть два метода, проверяющие, пригоден ли данный символ для использования в идентификаторе: метод isJavaIdentifierStart(), проверяющий, является ли символ буквой Java, и метод isJavaIdentifierPart(), выясняющий, является ли символ буквой, цифрой, знаком подчеркивания (_) или знаком доллара ($) .
Служебные слова Java, такие как class, void, static, зарезервированы, их нельзя использовать в качестве идентификаторов своих объектов.
Составное имя (qualified name) — это несколько идентификаторов, разделенных точками, без пробелов, например уже встречавшееся нам имя System.out.println.
Примитивные типы данных и операции
Все типы исходных данных, встроенные в язык Java, делятся на две группы: примитивные типы (primitive types) и ссылочные типы (reference types).
Ссылочные типы включают массивы (arrays), классы (classes) и интерфейсы (interfaces). Начиная с Java SE 5 появился перечислимый тип (enum).
Примитивных типов всего восемь. К ним относятся логический (иногда говорят булев) тип, называемый boolean, и семь числовых (numeric) типов.
Числовые типы делятся на целые (integral) и вещественные (floating-point).
Целых типов пять: byte, short, int, long, char.
Символы можно применять везде, где используется тип int, поэтому JLS причисляет тип char к целым типам. Например, символы можно использовать в арифметических вычислениях, скажем, можно написать 2 + 'Ж', к двойке будет прибавляться кодировка Unicode '\u04i6' буквы 'Ж'. В десятичной форме это число 1046, и в результате сложения получим 1048.
Напомним, что в записи 2 + "Ж", где буква Ж записана как строка, в кавычках, плюс понимается как сцепление строк, двойка будет преобразована в строку, в результате получится строка "2Ж".
Вещественных типов всего два: float и double.
На рис. 1.2 показана иерархия типов данных Java.
|
| byte short int long char float double Рис. 1.2. Типы данных языка Java |
Поскольку РїРѕ имени переменной невозможно определить ее тип, РІСЃРµ переменные обязательно должны быть описаны перед РёС… использованием. Описание заключается РІ том, что записывается РёРјСЏ типа, затем через пробел СЃРїРёСЃРѕРє имен переменных, относящихся Рє этому типу. Рмена РІ СЃРїРёСЃРєРµ разделяются запятой. Для всех или некоторых переменных можно указать начальные значения после знака равенства, которыми РјРѕРіСѓС‚ служить любые константные выражения того же типа. Описание каждого типа завершается точкой СЃ запятой. Р’ программе может быть сколько СѓРіРѕРґРЅРѕ описаний каждого типа.
Замечание для специалистов
Java — язык со строгой типизацией (strongly typed language).
Разберем каждый тип подробнее.
Логический тип
Значения логического типа boolean возникают РІ результате различных сравнений, РІСЂРѕРґРµ 2 > 3, Рё используются главным образом РІ условных операторах Рё операторах циклов. Логических значений всего РґРІР°: true (истина) Рё false (ложь). Рто служебные слова Java. Описание переменных данного типа выглядит так:
boolean b = true, bb = false, bool2;
Над логическими данными можно выполнять операции присваивания, например bool2 = true, в том числе и составные с логическими операциями; сравнение на равенство b == bb и на неравенство b != bb, а также логические операции.
Логические операции
В языке Java реализованы четыре логические операции:
□ отрицание (NOT) — ! (обозначается восклицательным знаком);
□ конъюнкция (AND) — & (амперсанд);
□ дизъюнкция (OR) — | (вертикальная черта);
в–Ў исключающее РЛР(XOR) — Р» (каре).
Они выполняются над логическими данными типа boolean, их результатом будет тоже логическое значение — true или false. Про эти операции можно ничего не знать, кроме того, что представлено в табл. 1.1.
|
Таблица 1.1.
Логические операции
|
| b1 |
b2 |
!b1 |
b1 & b2 |
b1 | b2 |
b1 Р» b2 |
| true |
true |
false |
true |
true |
false |
| true |
false |
false |
false |
true |
true |
| false |
true |
true |
false |
true |
true |
| false |
false |
true |
false |
false |
false |
Словами эти правила можно выразить так:
□ отрицание меняет значение истинности;
□ конъюнкция истинна, только если оба операнда истинны;
□ дизъюнкция ложна, только если оба операнда ложны;
в–Ў исключающее РЛРистинно, только если значения операндов различны.
ЗАМЕЧАНиЕ
Если бы Шекспир был программистом, фразу "To be or not to be" он написал бы так:
2b | ! 2b.
Кроме перечисленных четырех логических операций есть еще две логические операции сокращенного вычисления:
□ сокращенная конъюнкция (conditional-AND) — &&;
□ сокращенная дизъюнкция (conditional-OR) — | |.
Удвоенные знаки амперсанда и вертикальной черты следует записывать без пробелов.
Правый операнд сокращенных операций вычисляется только в том случае, если от него зависит результат операции, т. е. если левый операнд конъюнкции имеет значение true или левый операнд дизъюнкции имеет значение false.
Рто правило очень СѓРґРѕР±РЅРѕ Рё довольно ловко используется программистами, например можно записывать выражения (n != 0) && (m/n > 0.001) или (n == 0) | | (m/n > 0.001), РЅРµ опасаясь деления РЅР° нуль.
ЗАМЕЧАНиЕ
Практически всегда в Java используются именно сокращенные логические операции.
Упражнения
1. Для переменных b и bb, определенных в разд. "Логический тип" данной главы, найдите значение выражения b & bb && !bb | b.
2. При тех же определениях вычислите выражение (!b || bb) && (bb Л b).
Целые типы
Спецификация языка Java, JLS, определяет разрядность (количество байтов, выделяемых для хранения значений типа в оперативной памяти) каждого типа. Для целых типов она приведена в табл. 1.2. В таблице указан также диапазон значений каждого типа, получаемый на процессорах архитектуры Pentium.
|
Таблица 1.2.
Целые типы
|
|
РўРёРї
|
Разрядность(байт)
|
Диапазон
|
| byte |
1 |
РћС‚ -128 РґРѕ 127 |
| short |
2 |
РћС‚ -32 768 РґРѕ 32 767 |
| int |
4 |
РћС‚ -2 147 483 648 РґРѕ 2 147 483 647 |
| long |
8 |
РћС‚ -9 223 372 036 854 775 808 РґРѕ 9 223 372 036 854 775 807 |
| char |
2 |
От ’\u0000 ’ до ’ \uFFFF’, в десятичной форме от 0 до 65 535 |
Хотя тип char занимает два байта, в арифметических вычислениях он участвует как тип int, ему выделяется 4 байта, два старших байта заполняются нулями.
Вот примеры определения переменных целых типов:
byte b1 = 50, b2 = -99, b3; short det = 0, ind = 1, sh = ’d’;
int i = -100, j = 100, k = 9999;
long big = 50, veryBig = 2147483648L;
char c1 = 'A', c2 = '?', c3 = 36, newLine = '\n';
Целые типы, кроме char, хранятся в двоичном виде с дополнительным кодом. Последнее означает, что для отрицательных чисел хранится не их двоичное представление, а дополнительный код этого двоичного представления.
Дополнительный код получается так: в двоичном представлении числа все нули меняются на единицы, а единицы на нули, после чего к результату прибавляется единица, разумеется, в двоичной арифметике.
Например, значение 50 переменной b1, определенной ранее, будет храниться в одном байте с содержимым 00110010, а значение -99 переменной b2 — в байте с содержимым, которое вычисляется так: число 99 переводится в двоичную форму, получая 01100011, меняются единицы и нули, получая 10011100, и прибавляется единица, получая окончательно байт с содержимым 10011101.
Смысл всех этих преобразований РІ том, что сложение числа СЃ его дополнительным РєРѕРґРѕРј РІ двоичной арифметике даст РІ результате нуль; старший Р±РёС‚, равный 1, просто теряется, поскольку выходит Р·Р° разрядную сетку. Рто означает, что РІ такой странной арифметике дополнительный РєРѕРґ числа является противоположным Рє нему числом, числом СЃ обратным знаком. Рђ это, РІ СЃРІРѕСЋ очередь, означает, что вместо того, чтобы вычесть РёР· числа A число B, можно Рє A прибавить дополнительный РєРѕРґ числа B. Таким образом, операция вычитания исключается РёР· набора машинных операций.
Над целыми типами можно производить массу операций. РС… набор РІРѕСЃС…РѕРґРёС‚ Рє языку РЎ, РѕРЅ оказался удобным Рё кочует РёР· языка РІ язык почти без изменений. Особенности применения этих операций РІ языке Java показаны РЅР° примерах.
Операции над целыми типами
Все операции, которые производятся над целыми числами, можно разделить на следующие группы.
Арифметические операции
К арифметическим операциям относятся:
□ сложение — + (плюс);
□ вычитание — - (дефис);
□ умножение — * (звездочка);
□ деление — / (наклонная черта, слэш);
□ взятие остатка от деления (деление по модулю) — % (процент);
□ инкремент (увеличение на единицу) — ++;
□ декремент (уменьшение на единицу)---.
Между сдвоенными плюсами и минусами нельзя оставлять пробелы.
Сложение, вычитание Рё умножение целых значений выполняются как обычно, Р° РІРѕС‚ деление целых значений РІ результате дает опять целое (так называемое целочисленное деление), например 5/2 даст РІ результате 2, Р° РЅРµ 2,5, Р° 5/(-3) даст -1. Дробная часть попросту отбрасывается, РїСЂРѕРёСЃС…РѕРґРёС‚ так называемое усечение частного. Рто поначалу обескураживает, РЅРѕ потом оказывается удобным для усечения вещественных чисел.
Замечание
В Java принято целочисленное деление.
Рто странное для математики правило естественно для программирования: если РѕР±Р° операнда имеют РѕРґРёРЅ Рё тот же тип, то Рё результат имеет тот же тип. Достаточно написать 5/2.0 или 5.0/2 или 5.0/2.0, Рё получим 2,5 как результат деления вещественных чисел.
Операция деление по модулю определяется так:
a % b = a — (a / b) * b
например, 5%2 даст в результате 1, а 5%(-3) даст 2, т. к. 5 = (-3) * (-1) + 2, но (-5)%3 даст -2, поскольку -5 = 3 * (-1) — 2.
Операции инкремент и декремент означают увеличение или уменьшение значения переменной на единицу и применяются только к переменным, но не к константам или выражениям, нельзя написать 5++ или (a + b)++.
Например, после приведенных ранее описаний i++ даст -99, а j -- даст 99.
Рнтересно, что эти операции можно записать Рё перед переменной: ++i, --j. Разница проявится только РІ выражениях: РїСЂРё первой форме записи (постфиксной) РІ выражении участвует старое значение переменной Рё только потом РїСЂРѕРёСЃС…РѕРґРёС‚ увеличение или уменьшение ее значения. РџСЂРё второй форме записи (префиксной) сначала изменится переменная, Рё ее РЅРѕРІРѕРµ значение будет участвовать РІ выражении.
Например, после приведенных ранее описаний (k++) + 5 даст в результате 10004, а переменная k примет значение 10000. Но в той же исходной ситуации (++k) + 5 даст 10005, а переменная k станет равной 10000.
Приведение типов
Результат арифметической операции имеет тип int, кроме того случая, когда один из операндов типа long. В этом случае результат будет типа long.
Перед выполнением арифметической операции всегда происходит повышение (promotion) типов byte, short, char. Они преобразуются в тип int, а может быть, и в тип long, если другой операнд типа long. Операнд типа int повышается до типа long, если другой операнд типа long. Конечно, числовое значение операнда при этом не меняется.
Рто правило РїСЂРёРІРѕРґРёС‚ РёРЅРѕРіРґР° Рє неожиданным результатам. Попытка скомпилировать простую программу, представленную РІ листинге 1.3, приведет Рє сообщениям компилятора, показанным РЅР° СЂРёСЃ. 1.3.
Листинг 1.3. Неверное определение переменной
class InvalidDef{
public static void main(String[] args){
byte b1 = 50, b2 = -99;
short k = b1 + b2; // Неверно!
System.out.println(„k=" + k);
}
}
|
| Рис. 1.3. Сообщения компилятора об ошибке |
Рти сообщения означают, что РІ файле InvalidDefjava, РІ строке 4, обнаружена возможная потеря точности (possible loss of precision). Затем приводятся обнаруженный (found) Рё нужный (required) типы, выводится строка, РІ которой обнаружена (Р° РЅРµ сделана) ошибка, Рё отмечается СЃРёРјРІРѕР», РїСЂРё разборе которого найдена ошибка. Затем указано общее количество обнаруженных (Р° РЅРµ сделанных) ошибок (1 error).
В подобных ситуациях следует выполнить явное приведение типа. В данном случае это будет сужение (narrowing) типа int до типа short. Оно осуществляется операцией явного приведения, которая записывается перед приводимым значением в виде имени типа в скобках. Определение
short k = (short)(b1 + b2);
будет верным.
Сужение осуществляется просто отбрасыванием старших битов, что необходимо учитывать для больших значений. Например, определение
byte b = (byte)300;
даст переменной b значение 44. Действительно, в двоичном представлении числа 300, равном 100101100, отбрасывается старший бит и получается 00101100.
Таким же образом можно произвести и явное расширение (widening) типа, если в этом есть необходимость.
Если результат целой операции выходит за диапазон своего типа int или long, то автоматически происходит приведение по модулю, равному длине этого диапазона, и вычисления продолжаются, переполнение никак не отмечается и никаких сообщений об этом не появляется.
Замечание
В языке Java нет целочисленного переполнения.
Операции сравнения
В языке Java шесть обычных операций сравнения целых чисел по величине:
□ больше — >;
□ меньше — <;
□ больше или равно — >=;
□ меньше или равно — <=;
□ равно — ==;
□ не равно — !=.
Сдвоенные символы записываются без пробелов, их нельзя переставлять местами, запись => будет неверной.
Результат сравнения — логическое значение: true, например в результате сравнения 3 != 5; или false, например в результате сравнения 3 == 5.
Для записи сложных сравнений следует привлекать логические операции. Например, в вычислениях часто приходится делать проверки вида a < x < b. Подобная запись на языке Java приведет к сообщению об ошибке, поскольку первое сравнение, a < x, даст true или false, а Java не знает, больше это, чем ь, или меньше. В данном случае следует написать выражение (a < x) && (x < b), причем здесь скобки можно опустить, написать просто a < x && x < b, но об этом немного позднее.
Побитовые операции
РРЅРѕРіРґР° приходится изменять значения отдельных битов РІ целых данных. Рто выполняется СЃ помощью побитовых (bitwise) операций, как РіРѕРІРѕСЂСЏС‚, "наложением маски".
В языке Java четыре побитовые операции:
□ дополнение (complement)--(тильда);
□ побитовая конъюнкция (bitwise AND) — &;
□ побитовая дизъюнкция (bitwise OR) — |;
в–Ў побитовое исключающее РЛР(bitwise XOR) — Р».
Они выполняются поразрядно, после того как оба операнда будут приведены к одному типу int или long, так же как и для арифметических операций, а значит, и к одной разрядности. Операции над каждой парой битов выполняются согласно табл. 1.3.
|
Таблица 1.3.
Побитовые операции
|
| n1 |
n2 |
~n1 |
n1 & n2 |
n1 | n2 |
n1 Р» n2 |
| 1 |
1 |
0 |
1 |
1 |
0 |
| 1 |
0 |
0 |
0 |
1 |
1 |
| 0 |
1 |
1 |
0 |
1 |
1 |
| 0 |
0 |
1 |
0 |
0 |
0 |
В нашем примере число bi == 50, его двоичное представление 00110010, число b2 == -99, а его двоичное представление равно 10011101. Перед операцией происходит повышение типа byte до типа int. Получаем представления из 32-х разрядов для b1 — 0...00110010, а для b2 — 1...10011101. В результате побитовых операций получаем:
□ ~b2 == 98, двоичное представление — 0...01100010;
□ b1 & b2 == 16, двоичное представление — 0...00010000;
□ b1 | b2 == -65, двоичное представление — 1...10111111;
□ b1 Л b2 == -81, двоичное представление — 1...10101111.
Двоичное представление каждого результата занимает 32 бита.
Заметьте, что дополнение ~x всегда эквивалентно разности (-x) -1.
РЎРґРІРёРіРё
В языке Java есть три операции сдвига двоичных разрядов:
□ сдвиг влево — <<;
□ сдвиг вправо — >>;
□ беззнаковый сдвиг вправо — >>>.
Рти операции своеобразны тем, что левый Рё правый операнды РІ РЅРёС… имеют разный смысл. Слева стоит значение целого типа, Р° правая часть показывает, РЅР° сколько двоичных разрядов сдвигается значение, стоящее РІ левой части.
Например, операция b1 << 2 сдвинет влево на 2 разряда предварительно повышенное значение 0...00110010 переменной b1, что даст в результате 0...011001000, десятичное число — 200. Освободившиеся справа разряды заполняются нулями; левые разряды, находящиеся за 32-м битом, теряются.
Операция b2 << 2 сдвинет повышенное значение 1...10011101 на два разряда влево. В результате получим 1...1001110100, десятичное значение--396.
Заметьте, что сдвиг влево на n разрядов эквивалентен умножению числа на 2 в степени n.
Операция b1 >> 2 даст в результате 0...00001100, десятичное — 12, а b2 >> 2 — результат
1...11100111, десятичное--25, т. е. слева распространяется старший бит, правые биты
теряются. Рто так называемый арифметический СЃРґРІРёРі.
Операция беззнакового сдвига во всех случаях ставит слева на освободившиеся места нули, осуществляя логический сдвиг. Но вследствие предварительного повышения это имеет эффект только для нескольких старших разрядов отрицательных чисел. Так, b2 >>> 2 имеет результатом 001...100111, десятичное число — 1 073 741 799.
Если же мы хотим получить логический сдвиг исходного значения 10011101 переменной b2, т. е. 0...00100111, надо предварительно наложить на b2 маску, обнулив старшие биты:
(b2 & 0xFF) >>> 2.
Замечание
Будьте осторожны при использовании сдвигов вправо.
Упражнения
3. Каково значение выражения ' D' + 5?
При определениях, сделанных ранее, вычислите выражения:
4. (b1 + СЃ1) % (++b2 / b1++).
5. (b1 < СЃ1) && (b2 == -99) || (ind >= 0).
6. (b1 | СЃ1) & (big Р› b1).
7. (b1<<3 + СЃ1<<2) % (b2>>5 / b1>>>2).
Вещественные типы
Вещественных типов в Java два: float и double. Они характеризуются разрядностью, диапазоном значений и точностью представления, отвечающим стандарту IEEE 7541985 с некоторыми изменениями. К обычным вещественным числам добавляются еще три значения:
□ положительная бесконечность, выражаемая константой positive_infinity и возникающая при переполнении положительного значения, например в результате операции умножения 3.0*6e307 или при делении на нуль;
□ отрицательная бесконечность negative_infinity, возникающая при переполнении отрицательного значения, например в результате операции умножения -3.0*6e307 или при делении на нуль отрицательного числа;
□ "не число", записываемое константой NaN (Not a Number) и возникающее, например, при умножении нуля на бесконечность.
В главе 4 мы поговорим о них подробнее.
Кроме того, стандарт различает положительный и отрицательный нуль, возникающий при делении на бесконечность соответствующего знака, хотя сравнение 0.0 == -0.0 дает в результате истину, true.
Операции с бесконечностями выполняются по обычным математическим правилам.
Во всем остальном вещественные типы — это обычные вещественные значения, к которым применимы все арифметические операции и сравнения, перечисленные для целых типов. Характеристики вещественных типов приведены в табл. 1.4.
Знатокам C/C++
В языке Java взятие остатка от деления %, инкремент ++ и декремент — применяются и к вещественным типам.
|
Таблица 1.4.
Вещественные типы
|
|
РўРёРї
|
Разрядность
|
Диапазон
|
Точность
|
| float |
4 байта |
3,4x10 -38 < |С…| < 3,4x10 38 |
7—8 цифр в дробной части |
| double |
8 байтов |
1,7х10“ 308 < |х| < 1,7x10 308 |
17 цифр в дробной части |
Примеры определения вещественных типов:
float x = 0.001f, y = -34.789F; double z1 = -16.2305, z2;
Поскольку к вещественным типам применимы все арифметические операции и сравнения, целые и вещественные значения можно смешивать в операциях. При этом правило приведения типов дополняется такими условиями:
□ если в операции один операнд имеет тип double, то и другой приводится к типу
double;
□ иначе, если один операнд имеет тип float, то и другой приводится к типу float;
□ в противном случае действует правило приведения целых значений.
Операции присваивания
Простая операция присваивания (simple assignment operator) записывается знаком равенства (=), слева от которого стоит переменная, а справа — выражение, совместимое с типом переменной: x = 3.5, у = 2 * (x - 0.567) / (x + 2), b = x < y, bb = x >= y && b.
Операция присваивания действует так: выражение, стоящее после знака равенства, вычисляется и приводится к типу переменной, стоящей слева от знака равенства. Результатом операции будет приведенное значение правой части.
Операция присваивания имеет еще одно, побочное, действие: переменная, стоящая слева, получает приведенное значение правой части, старое ее значение теряется.
В операции присваивания левая и правая части неравноправны, нельзя написать 3.5 = x. После операции x = y изменится переменная x, став равной y, а после y = x изменится переменная y.
Кроме простой операции присваивания есть еще 11 составных операций присваивания (compound assignment operators): +=, -=, *=, /=, %=, &=, |=, Л=, <<=, >>=, >>>=. Символы запи
сываются без пробелов, нельзя переставлять их местами.
Все составные операции присваивания действуют по одной схеме:
x операция = a
эквивалентно
x = (тип x)(x операция a)
Напомним, что переменная ind типа short определена Сѓ нас СЃРѕ значением 1. Присваивание ind += 7.8 даст РІ результате число 8, то же значение получит Рё переменная ind. Рта операция эквивалентна простой операции присваивания ind = (short)(ind + 7.8).
Перед присваиванием, при необходимости, автоматически производится приведение типа. Поэтому:
byte b = 1;
b = b + 10; // Ошибка!
b += 10; // Правильно!
Перед сложением b + 10 происходит повышение b до типа int, результат сложения тоже будет типа int и, в первом случае, результат не может быть присвоен переменной b без явного приведения типа. Во втором случае перед присваиванием произойдет сужение результата сложения до типа byte.
Упражнения
8. Чему равно выражение x = y = z = 1?
9. Что получится в результате присваиваний x += y -= z /= x + 2?
Условная операция
Рта своеобразная операция имеет три операнда. Вначале записывается произвольное логическое выражение, С‚. Рµ. имеющее РІ результате true или false, затем знак РІРѕРїСЂРѕСЃР°, потом РґРІР° произвольных выражения, разделенных двоеточием, например:
x < 0 ? 0 : x x > y ? x — y : x + y
Условная операция выполняется так. Сначала вычисляется логическое выражение. Если получилось значение true, то вычисляется первое выражение после вопросительного знака и его значение будет результатом всей операции. Последнее выражение при этом не вычисляется. Если же получилось значение false, то вычисляется только последнее выражение, его значение будет результатом операции.
Рто позволяет написать n == 0 ? m : m / n, РЅРµ опасаясь деления РЅР° нуль. Условная операция поначалу кажется странной, РЅРѕ РѕРЅР° очень СѓРґРѕР±РЅР° для записи небольших разветвлений.
Упражнения
10. Каков смысл операции x > 0 ? x : -x?
11. Что дает в результате операция x > y ? x : y?
12. Что получится в результате операции x > y ? y : x?
Выражения
РР· констант Рё переменных, операций над РЅРёРјРё, вызовов методов Рё СЃРєРѕР±РѕРє составляются выражения (expressions). Разумеется, РІСЃРµ элементы выражения должны быть совместимы, нельзя написать, например, 2 + true. РџСЂРё вычислении выражения выполняются четыре правила.
в–Ў Операции РѕРґРЅРѕРіРѕ приоритета вычисляются слева направо: x + y + z вычисляется как (x + y) + z. Рсключение: операции присваивания вычисляются справа налево: x = y = z вычисляется как x = (y = z) .
□ Левый операнд вычисляется раньше правого.
□ Операнды полностью вычисляются перед выполнением операции.
□ Перед выполнением составной операции присваивания значение левой части сохраняется для использования в правой части.
Следующие примеры показывают особенности применения первых трех правил. Пусть
int a = 3, b = 5;
Тогда результатом выражения b + (b = 3) будет число 8; но результатом выражения (b = 3) + b будет число 6. Выражение b += (b = 3) даст в результате 8, потому что вычисляется как первое из приведенных выражений.
Знатокам C/C++
Большинство компиляторов языка C++ во всех этих случаях вычислят значение 8.
Четвертое правило можно продемонстрировать так. При тех же определениях переменных a и b в результате вычисления выражения
b += a += b += 7
получим 20. Хотя операции присваивания выполняются справа налево и после первой, самой правой, операции значение b становится равным 12, но в последнем, левом, присваивании участвует старое значение b, равное 5. А в результате двух последовательных вычислений
a += b += 7; b += a;
получим 27, поскольку во втором выражении участвует уже новое значение переменной b, равное 12.
Знатокам C/C++
Большинство компиляторов C++ в обоих случаях вычислят 27.
Выражения могут иметь сложный и запутанный вид. В таких случаях возникает вопрос о приоритете операций, т. е. о том, какие операции будут выполнены в первую очередь. Естественно, умножение и деление производится раньше сложения и вычитания. Остальные правила перечислены в следующем разделе.
Порядок вычисления выражения всегда можно отрегулировать скобками, скобок можно ставить сколько угодно. Но здесь важно соблюдать "золотую середину". При большом количестве скобок снижается наглядность выражения и легко ошибиться в расстановке скобок. Если выражение со скобками корректно, то компилятор может отследить только парность скобок, но не правильность их расстановки.
Приоритет операций
Операции перечислены в порядке убывания приоритета. Операции на одной строке имеют одинаковый приоритет.
1. Постфиксные операции ++ и —.
2. Префиксные операции ++ и --, дополнение ~ и отрицание !.
3. Приведение типа (тип).
4. Умножение *, деление / и взятие остатка %.
5. Сложение + и вычитание -.
6. РЎРґРІРёРіРё: <<, >>, >>>.
7. Сравнения: >, <, >=, <=.
8. Сравнения: ==, !=.
9. Побитовая конъюнкция — &.
10. Побитовое исключающее РЛР— Р».
11. Побитовая дизъюнкция — |.
12. Конъюнкция — &&.
13. Дизъюнкция — | |.
14. Условная операция — ?:.
15. Присваивания: =, +=, -=, *=, /=, %=, &=, л=, |=, <<=, >>=, >>>=.
Здесь перечислены не все операции языка Java, список будет дополняться по мере изучения новых операций.
Знатокам C/C++
В Java нет операции "запятая", но список выражений используется в операторе цикла for.
Операторы
Как вы знаете, любой алгоритм, предназначенный для выполнения на компьютере, можно разработать, используя только линейные вычисления, разветвления и циклы.
Записать его можно в разных формах: в виде блок-схемы, на псевдокоде, на обычном языке, как мы записываем кулинарные рецепты, или как-нибудь еще.
Всякий язык программирования должен иметь средства записи алгоритмов. Они называются операторами (statements) языка. Минимальный набор операторов должен содержать оператор для записи линейных вычислений, условный оператор для записи разветвлений и оператор цикла.
Обычно состав операторов языка программирования шире: для удобства записи алгоритмов в язык включаются несколько операторов цикла, оператор варианта, операторы перехода, операторы описания объектов.
Набор операторов языка Java включает:
□ операторы описания переменных и других объектов (были рассмотрены ранее);
□ операторы-выражения;
□ операторы присваивания;
□ условный оператор if;
□ три оператора цикла while, do-while, for;
□ оператор варианта switch;
□ операторы перехода break, continue и return;
□ блок, выделяемый фигурными скобками {};
□ пустой оператор — просто точка с запятой.
Здесь приведен не весь набор операторов Java, он будет дополняться по мере изучения языка.
Замечание
В языке Java нет оператора goto.
Всякий оператор завершается точкой с запятой.
Можно поставить точку с запятой в конце любого выражения, и оно станет оператором (expression statement). Но это имеет смысл только для операций присваивания, инкремента и декремента и вызовов методов. В остальных случаях это бесполезно, потому что вычисленное значение выражения потеряется.
Знатокам Pascal
Точка с запятой в Java не разделяет операторы, а является частью оператора.
Линейное выполнение алгоритма обеспечивается последовательной записью операторов. Переход со строки на строку в исходном тексте не имеет никакого значения для компилятора, он осуществляется только для наглядности и читаемости текста.
Блок
Блок заключает в себе нуль или несколько операторов с целью использовать их как один оператор в тех местах, где по правилам языка можно записать только один оператор. Например, {х = 5; у = 7;}. Можно записать и пустой блок, просто пару фигурных скобок {} .
Блоки операторов часто применяются для ограничения области действия переменных, а иногда просто для улучшения читаемости текста программы.
Операторы присваивания
Точка с запятой в конце любой операции присваивания превращает ее в оператор присваивания. Побочное действие операции — присваивание — становится в операторе основным.
Разница между операцией и оператором присваивания носит лишь теоретический характер. Присваивание чаще используется как оператор, а не как операция.
Условный оператор
Условный оператор (if-then-else statement) предназначен для организации разветвлений в программе. На языке Java он записывается так:
if (логВыр) оператор1 else оператор2
Рё действует следующим образом. Сначала вычисляется логическое выражение логВыр. Если результат вычисления true, то действует оператор1, Рё РЅР° этом работа условного оператора завершается, оператор2 РЅРµ действует. Далее будет выполняться оператор, следующий Р·Р° оператором if. Рто так называемая "ветвь then" условного оператора. Если результат логического выражения false, то действует оператор2, РїСЂРё этом оператор1 вообще РЅРµ выполняется ("ветвь else").
Условный оператор может быть сокращенным, без ветви else (if-then statement):
if (логВыр) оператор1
В том случае, когда логВыр равно false, не выполняется ничего, как будто бы условного оператора не было.
Синтаксис языка не позволяет записывать несколько операторов ни в ветви then, ни в ветви else. При необходимости составляется блок операторов в фигурных скобках. Соглашения "Code Conventions" рекомендуют всегда использовать фигурные скобки и размещать оператор на нескольких строках с отступами, как в следующем примере:
if (a < С…){
С… = a + b;
} else {
х = a — b;
}
Рто облегчает добавление операторов РІ каждую ветвь РїСЂРё изменении алгоритма. РњС‹ РЅРµ будем строго следовать этому правилу, чтобы РЅРµ увеличивать объем РєРЅРёРіРё.
Очень часто одним из операторов является опять-таки условный оператор, например:
if (n == 0){ sign = 0;
} else if (n < 0){ sign = -1;
} else {
sign = 1;
}
При этом может возникнуть такая ситуация ("dangling else"):
int ind = 5, x = 100;
if (ind >= 10) if (ind <= 20) x = 0; else x = 1;
К какому условию if относится ветвь else, первому или второму? Сохранит переменная х значение 100 или станет равной 1? Здесь необходимо волевое решение, и общее для большинства языков, в том числе и Java, правило таково: ветвь else относится к ближайшему слева условию if, не имеющему своей ветви else. Поэтому в нашем примере переменная х останется равной 100.
Рзменить этот РїРѕСЂСЏРґРѕРє можно СЃ помощью блока:
if (ind > 10) {if (ind < 20) С… = 0;} else С… = 1;
Вообще, не стоит увлекаться сложными вложенными условными операторами. Проверки условий занимают много времени. По возможности лучше использовать логические операции, например предыдущий условный оператор лучше записать так:
if (ind >= 10 && ind <= 20) С… = 0; else С… = 1;
В листинге 1.4 условный оператор применяется для вычисления корней квадратного уравнения ax 2 + bx + c = 0 для любых коэффициентов, в том числе и нулевых.
Листинг 1.4. Вычисление корней квадратного уравнения
class QuadraticEquation{
public static void main(String[] args){
double a = 0.5, b = -2.7, c = 3.5, d, eps=1e-8; if (Math.abs(a) < eps) if (Math.abs(b) < eps)
if (Math.abs(c) < eps) // Все коэффициенты равны нулю
System.out.println("Решение — любое число");
else
System.out.println("Решений нет");
else
System.out.println(,,x1 = х2 = " +(-c / b)); else { // Коэффициенты не равны нулю
if((d = b*b — 4*a*c)< 0.0){ // Комплексные корни
d = 0.5 * Math.sqrt(-d) / a; a = -0.5 * b/ a;
System.out.println(,,x1 = " +a+ " +i " +d+", С…2 = " +a+ " -i " +d);
} else { // Вещественные корни
d = 0.5 * Math.sqrt(d) / a; a = -0.5 * b / a;
System.out.println("х1 = " +(a + d)+ ", х2 = " +(a — d));
}
}
}
}
В этой программе использованы методы вычисления модуля abs() и вычисления квадратного корня sqrt () из вещественного числа, взятые из входящего в Java API класса Math. Поскольку все вычисления с вещественными числами производятся приближенно, не следует ожидать, что вещественное число будет точно равно нулю. Поэтому мы считаем, что коэффициент уравнения равен нулю, если его модуль меньше 0,00000001. Обратите внимание на то, как в методе println () используется сцепление строк, и на то, как операция присваивания при вычислении дискриминанта вложена в логическое выражение, записанное в условном операторе.
"Продвинутым" пользователям
Вам уже хочется вводить коэффициенты a, b Рё СЃ РїСЂСЏРјРѕ СЃ клавиатуры? Пожалуйста. Рспользуйте метод System.in.read(byte[] bt), РЅРѕ учтите, что РѕРЅ записывает вводимые цифры РІ массив байтов bt РІ РєРѕРґРёСЂРѕРІРєРµ ASCII, РІ каждый байт РїРѕ РѕРґРЅРѕР№ цифре. Массив байтов затем надо преобразовать РІ вещественное число, например методом Double (new string(bt)).doubleValue(). Непонятно? Загляните РІ главу 23. РќРѕ это еще РЅРµ РІСЃРµ, нужно обработать исключительные ситуации, которые РјРѕРіСѓС‚ возникнуть РїСЂРё РІРІРѕРґРµ (СЃРј. главу 21).
Упражнения
13. Вычислите с помощью условного оператора значение у, равное х + 1, если х < 0, равное х + 2, если 0 <= х < 1, и равное х + 10 в остальных случаях.
14. Запишите условный оператор, дающий логической переменной z значение true, если точка M^, у) лежит в единичном круге с центром в начале координат, и значение false в противном случае.
Операторы цикла
Основной оператор цикла — оператор while — выглядит так:
while (логВыр) оператор
Вначале вычисляется логическое выражение логВыр. Если его значение true, то выполняется оператор, образующий цикл. Затем снова вычисляется логВыр и действует оператор, и так до тех пор, пока не получится значение false. Если логВыр изначально равняется false, то оператор не будет выполнен ни разу. Предварительная проверка условия выполнения цикла обеспечивает безопасность выполнения цикла, позволяет избежать переполнения, деления на нуль и других неприятностей. Поэтому оператор while является основным, а в некоторых языках и единственным оператором цикла.
Оператор в цикле может быть и пустым, например следующий фрагмент кода:
int i = 0; double s = 0.0;
while ((s += 1.0 / ++i) < 10);
вычисляет количество i сложений, которые необходимо сделать, чтобы гармоническая сумма s достигла значения 10. Такой стиль характерен для языка С. Не стоит им увлекаться, чтобы не превратить текст программы в шифровку, на которую вы сами через пару недель будете смотреть с недоумением, пытаясь понять, что же делают эти операторы.
Можно организовать и бесконечный цикл:
while (true) оператор
Конечно, из такого цикла следует предусмотреть какой-то выход, например оператором break, как сделано в листинге 1.5. В противном случае программа зациклится, и вам придется прекращать ее выполнение комбинацией клавиш + в UNIX или через окно Task Manager в Windows.
Если в цикл надо включить несколько операторов, то следует образовать блок операторов {} .
Второй оператор цикла — оператор do-while — имеет вид:
do оператор while (логВыр)
Здесь сначала выполняется оператор, а потом происходит вычисление логического выражения логВыр. Цикл выполняется, пока логВыр остается равным true.
Знатокам Pascal
В цикле do-while проверяется условие продолжения, а не окончания цикла.
Существенное различие между этими двумя операторами цикла только в том, что в цикле do-while оператор обязательно выполнится хотя бы один раз.
Например, пусть задана какая-то функция fx), имеющая на отрезке [a; b] ровно один корень. В листинге 1.5 приведена программа, вычисляющая этот корень приближенно методом деления пополам (бисекции, дихотомии).
Листинг 1.5. Нахождение корня нелинейного уравнения методом бисекции
class Bisection{
static double f(double С…){
return С…*С…*С… — 3*x*x + 3; // Рли что-то РґСЂСѓРіРѕРµ...
}
public static void main(String[] args){
double a = 0.0, b = 1.5, c, y, eps = 1e-8;
do{
c = 0.5 *(a + b); y = f(c); if (Math.abs(y) < eps) break;
// Корень найден. Выходим из цикла
// Если на концах отрезка [a; c] функция имеет разные знаки:
if (f(a) * y < 0.0) b = c;
// Значит, корень здесь. Переносим точку b в точку c // В противном случае: else a = c;
// Переносим точку a в точку c
// Продолжаем, пока отрезок [a; b] не станет мал } while(Math.abs(b-a) >= eps);
System.out.println("x = " +c+ ", f(" +c+ ") = " +y);
}
}
Класс Bisection сложнее предыдущих примеров: в нем кроме метода main() есть еще метод вычисления функции fx). Здесь метод f () очень прост: он вычисляет значение многочлена и возвращает его в качестве значения функции, причем все это выполняется одним оператором:
return выражение
В методе main () появился еще один новый оператор — break, который просто прекращает выполнение цикла, если мы по счастливой случайности наткнулись на приближенное значение корня. Внимательный читатель заметил и появление модификатора static в объявлении метода f(). Он необходим потому, что метод f() вызывается из статического метода main (), о чем мы поговорим в следующей главе.
Третий оператор цикла — оператор for — выглядит так:
for (списокВыр1; логВыр; списокВыр2) оператор
Перед выполнением цикла вычисляется СЃРїРёСЃРѕРє выражений списокВыр1. Рто нуль или несколько выражений, перечисленных через запятую. РћРЅРё вычисляются слева направо, Рё РІ следующем выражении уже можно использовать результат предыдущего выражения. Как правило, здесь задаются начальные значения переменным цикла.
Затем вычисляется логическое выражение логВыр. Если оно истинно, true, то действует оператор, потом вычисляются слева направо выражения из списка выражений списокВыр2.
Далее снова проверяется логВыр. Если оно истинно, то выполняется оператор и списокВыр2 и т. д. Как только логВыр станет равным false, выполнение цикла заканчивается.
Короче говоря, выполняется последовательность операторов
списокВыр1; while (логВыр){ оператор списокВыр2;
}
с тем исключением, что если оператором в цикле является оператор continue, то список-Выр2 все-таки выполняется.
Вместо списокВыр1 может стоять одно определение переменной обязательно с начальным значением. Такие переменные известны лишь в пределах этого цикла.
Любая часть оператора for может отсутствовать: цикл может быть пустым, выражения в заголовке тоже, при этом точки с запятой сохраняются. Можно даже задать бесконечный цикл:
for (;;) оператор
В этом случае в теле цикла следует предусмотреть какой-нибудь выход из него.
Хотя в операторе for заложены большие возможности, используется он главным образом для перечислений, когда их количество известно, например фрагмент кода
int s = 0;
for (int k = 1; k <= N; k++) s += k * k;
// Здесь переменная k уже неизвестна
вычисляет сумму квадратов первых N натуральных чисел.
В языке Java есть еще одна форма оператора for, так называемый оператор "for-each", который используется для перебора элементов массивов и коллекций. Мы познакомимся с ним в разделе этой главы, посвященном массивам.
Оператор continue и метки
Оператор continue используется только в операторах цикла. Он имеет две формы. Первая форма состоит только из слова continue и осуществляет немедленный переход к следующей итерации цикла. В очередном фрагменте кода оператор continue позволяет обойти деление на нуль:
for (int i = 0; i < N; i++){ if (i == j) continue; s += 1.0 / (i — j);
}
Вторая форма содержит метку:
continue метка
Метка записывается, как все идентификаторы, из букв Java, цифр и знака подчеркивания, но не требует никакого описания. Метка ставится перед оператором или открывающей фигурной скобкой и отделяется от них двоеточием. Так получается помеченный оператор или помеченный блок.
Знатокам Pascal
Метка не требует описания и не может начинаться с цифры.
Вторая форма используется только в случае нескольких вложенных циклов для немедленного перехода к очередной итерации одного из объемлющих циклов, а именно помеченного цикла.
Оператор break
Оператор break используется в операторах цикла и операторе варианта для немедленного выхода из этих конструкций.
Оператор
break метка
применяется внутри помеченных операторов цикла, оператора варианта или помеченного блока для немедленного выхода за эти операторы. Следующая схема поясняет данную конструкцию.
M1: { // Внешний блок
M2: { // Вложенный блок — второй уровень M3: { // Третий уровень вложенности... if (что-то случилось) break M2;
// Если true, то здесь ничего не выполняется
}
// Здесь тоже ничего не выполняется
}
// Сюда передается управление
}
Поначалу сбивает СЃ толку то обстоятельство, что метка ставится перед блоком или оператором, Р° управление передается Р·Р° этот блок или оператор. Рто затрудняет чтение программы, поэтому РЅРµ стоит увлекаться оператором break СЃ меткой.
Упражнения
15. Напишите цикл, вычисляющий факториал заданного натурального числа.
16. Напишите цикл, определяющий, какая наибольшая степень числа 2 содержится среди делителей заданного натурального числа.
Оператор варианта
Оператор варианта switch организует разветвление по нескольким направлениям. Каждая ветвь отмечается константой или константным выражением какого-либо целого типа (кроме long) и выбирается, если значение определенного выражения совпадет с этой константой. Вся конструкция выглядит так: switch (выражение){
case констВыр1: оператор1 case констВыр2: оператор2
case констВырЫ: операторN default: операторDef
}
Стоящее в скобках выражение может быть простого целого типа byte, short, int, char, но не long. Целые числа, символы, или целочисленные выражения, составленные из констант, констВыр, тоже не должны быть типа long.
Кроме простых целых типов допускаются их классы-оболочки, перечисления и строки символов типа String, которые мы рассмотрим в следующих главах. При этом тип константных выражений должен соответствовать типу выражения. Посмотрите, например, листинги 3.4 и 28.9.
Оператор варианта выполняется так. Все константные выражения вычисляются заранее, на этапе компиляции, и должны иметь отличные друг от друга значения. Сначала вычисляется выражение, записанное в круглых скобках. Если оно совпадает с одной из констант, то выполняется оператор, отмеченный этой константой. Затем выполняются ("fall through labels") все следующие операторы, включая и операторDef, и работа оператора варианта заканчивается.
Если же ни одна константа не равна значению выражения, то выполняется операторDef и все следующие за ним операторы. Поэтому ветвь default должна записываться последней. Ветвь default может отсутствовать, тогда в этой ситуации оператор варианта вообще ничего не делает.
Таким образом, константы в вариантах case играют роль только меток, точек входа в один из вариантов, а далее выполняются все оставшиеся варианты в порядке их записи.
Знатокам Pascal
После выполнения одного варианта оператор switch продолжает выполнять все оставшиеся варианты.
Чаще всего необходимо "пройти" только одну ветвь операторов. В таком случае используется оператор break, сразу же прекращающий выполнение оператора switch.
С другой стороны, может понадобиться выполнить один и тот же оператор в разных ветвях case. В этом случае ставим несколько меток case подряд. Вот простой пример.
switch (dayOfWeek){
case 1: case 2: case 3: case 4: case 5:
System.out.println("Рабочий день"); break; case 6: case 7:
System.out.println("Выходной день"); break; default:
System.out.println("Нeправильно задан день недели");
}
Если дни недели заданы строковыми константами, то предыдущий оператор можно записать так:
switch (dayOfWeek){
case "Mon": case "Tue": case "Wed": case "Thu": case "Fri": System.out.println("Рабочий день"); break; case "Sat": case "Sun":
System.out.println("Выходной день"); break; default:
System.out.println("Нeправильно задан день недели");
}
Замечание
Не забывайте завершать варианты оператором break, если нужно выполнить только один вариант.
Массивы
Как всегда в программировании, массив — это совокупность переменных одного типа, хранящих свои значения в смежных ячейках оперативной памяти.
Массивы в языке Java относятся к ссылочным типам и описываются своеобразно, но характерно для ссылочных типов. Описание производится в три этапа.
Первый этап — объявление (declaration). На этом этапе определяется только переменная типа ссылка (reference) на массив, содержащая тип массива. Для этого записывается имя типа элементов массива, квадратными скобками указывается, что объявляется ссылка на массив, а не простая переменная, и перечисляются имена переменных ссылочного типа, например
double[] a, b;
Здесь определены РґРІРµ переменные — ссылки a Рё b РЅР° массивы типа double. Можно поставить квадратные СЃРєРѕР±РєРё Рё непосредственно после имени. Рто СѓРґРѕР±РЅРѕ делать, если массив объявляется среди определений обычных переменных:
int i = 0, ar[], k = -1;
Здесь определены две переменные целого типа i и k и объявлена ссылка на целочисленный массив ar.
Второй этап — определение (instantation). На этом этапе указывается количество элементов массива, называемое его длиной, выделяется место для массива в оперативной памяти, переменная-ссылка получает адрес массива. Все эти действия производятся еще одной операцией языка Java — операцией new тип, выделяющей участок в оперативной памяти для объекта, указанного в операции типа, и возвращающей в качестве результата адрес этого участка.
Например,
a = new double[5]; b = new double[100]; ar = new int[50];
При этом все элементы массива получают нулевые значения.
Рндексы массивов всегда начинаются СЃ 0. Массив a состоит РёР· пяти переменных: a[0], a[1] ... a[4] . Рлемента a[5] РІ массиве нет. Рндексы можно задавать любыми целочисленными выражениями, РєСЂРѕРјРµ типа long, например a[i+j], a[i%5], a[++i]. Рсполняющая система Java следит Р·Р° тем, чтобы значения этих выражений РЅРµ выходили Р·Р° границы длины массива. Рнтерпретатор Java РІ таком случае прекратит выполнение программы Рё выведет РЅР° консоль сообщение Рѕ выходе индекса массива Р·Р° границы его определения.
Третий этап — инициализация (initialization). На этом этапе элементы массива получают начальные значения. Например,
a[0] = 0.01; a[1] = -3.4; a[2] = 2.89; a[3] = 4.5; a[4] = -6.7; for (int i = 0; i < 100; i++) b[i] = 1.0 / i; for (int i = 0; i < 50; i++) ar[i] = 2 * i + 1;
Первые два этапа можно совместить:
double[] a = new double[5], b = new double[100]; int i = 0, ar[] = new int[50], k = -1;
Можно сразу задать и начальные значения, записав их в фигурных скобках через запятую в виде констант или константных выражений. При этом даже необязательно указывать количество элементов массива, оно будет равно количеству начальных значений:
double[] a = {0.01, -3.4, 2.89, 4.5, -6.7};
Можно совместить второй и третий этап:
a = new double[] {0.1, 0.2, -0.3, 0.45, -0.02};
Можно даже создать безымянный массив, сразу же используя результат операции new, например так:
System.out.println(new char[] {THT, 'e', TlT, TlT, 'o'});
Ссылка на массив не является частью описанного массива, ее можно перебросить на другой массив того же типа операцией присваивания. Например, после присваивания a = b обе ссылки a и b будут указывать на один и тот же массив из 100 вещественных переменных типа double и содержать один и тот же адрес.
Ссылка может присвоить "пустое" значение null, не указывающее ни на какой адрес оперативной памяти:
ar = null;
После этого массив, на который указывала данная ссылка, теряется, если на него не было других ссылок.
Кроме простой операции присваивания со ссылками можно производить еще только сравнения на равенство, например a == b, и неравенство — a != b. При этом сопоставляются адреса, содержащиеся в ссылках; мы можем узнать, не ссылаются ли они на один и тот же массив.
Замечание для специалистов
Массивы в Java всегда определяются динамически, хотя ссылки на них задаются статически.
Кроме ссылки на массив для каждого массива автоматически определяется целая константа с одним и тем же именем length. Ее значение равно длине массива. Для каждого массива имя этой константы уточняется именем массива через точку. Так, после наших определений, константа a.length равна 5, константа b.length равна 100, а ar.length равна 50.
РЎ помощью константы length последний элемент массива a можно записать так: a[a.length - 1], предпоследний — a[a.length - 2] Рё С‚. Рґ. Рлементы массива обычно перебираются РІ цикле РІРёРґР°:
double aMin = a[0], aMax = aMin; for (int i = 0; i < a.length; i++){ if (a[i] < aMin) aMin = a[i]; if (a[i] > aMax) aMax = a[i];
}
double range = aMax - aMin;
Здесь вычисляется диапазон значений массива. Заметьте, что цикл можно было бы начать с 1.
Ситуация, когда надо перебрать все элементы массива в порядке возрастания их индексов, как в предыдущем примере, встречается очень часто. Начиная с версии Java SE 5, для таких случаев в язык Java введена упрощенная форма оператора цикла for, так называемый оператор "for-each", уже упоминавшийся ранее. Вот как можно записать предыдущий пример оператором "for-each":
double aMin = a[0], aMax = aMin; for (double x : a){
if (x < aMin) aMin = x; if (x > aMax) aMax = x;
}
double range = aMax - aMin;
Обратите внимание РЅР° то, что РІ цикле for сразу определяется переменная x того же типа, что Рё элементы массива. Рта переменная принимает последовательно значения всех элементов массива РѕС‚ первого элемента РґРѕ последнего.
Рлементы массива — это обыкновенные переменные своего типа, СЃ РЅРёРјРё можно производить РІСЃРµ операции, допустимые для этого типа: (a[2] + a[4]) / a[0] Рё С‚. Рґ.
Знатокам C/C++
Массив символов в Java не является строкой, даже если он заканчивается нуль-символом
T\u0000 T.
Многомерные массивы
Рлементами массивов РІ Java РјРѕРіСѓС‚ быть массивы. Можно объявить ссылку:
char [][] c;
что эквивалентно
char [] c[];
или char c[] [];
Затем определяем внешний массив и его размерность:
c = new char[3][];
Становится ясно, что с — массив, состоящий из трех элементов-массивов. Теперь определяем его элементы-массивы:
c[0] = new char[2]; c[1] = new char[4]; c[2] = new char[3];
После этих определений переменная c.length равна 3, c[0] .length равна 2, c[1] .length равна 4 и c[2]. length равна 3.
Наконец, задаем начальные значения c[0][0] = Ta% c[0][1] = Tr% c[1][0] = Tr’,
c[1] [1] = TaT, c[1] [2] = TyT Рё С‚. Рґ.
Замечание
Двумерный массив в Java не обязан быть прямоугольным.
Описания можно сократить:
int[] [] d = new int[3] [4];
А начальные значения задать так:
int[][] inds = {{1, 2, 3}, {4, 5, 6}};
В листинге 1.6 приведен пример программы, вычисляющей первые 10 строк треугольника Паскаля, заносящей их в треугольный массив и выводящей его элементы на экран. Рисунок 1.4 показывает вывод этой программы.
Листинг 1.6. Треугольник Паскаля
class PascalTriangle{
public static final int LINES = 10; // Так определяются константы
public static void main(String[] args){ int [][] p = new int [LINES] [ ] ; p[0] = new int[1];
System.out.println(p[0][0] = 1); p[1] = new int[2]; p[1] [0] = p[1] [1] = 1;
System.out.println(p[1][0] + " " + p[1][1]); for (int i = 2; i < LINES; i++){ p[i] = new int[i+1];
System.out.print((p[i][0] = 1) + " "); for (int j = 1; j < i; j++)
System.out.print((p[i][j] = p[i-1][j-1] + p[i-1][j]) + " "); System.out.println(p[i][i] = 1);
}
}
\ Command Prompt
| 10 10 5 115 20 15 6 1 21 35 35 21 7 1 28 56 70 56 28 8 1 36 84 126 126 84 36 9 1 |
|
Microsoft Windows [Uersion 5.2.3790]
Copyright 1985-2003 Microsoft Corp.
C:\>cd progs
C:\progs>jauac PascalTriangle.jaua
C:\progs>java PascalTriangle 1
Рис. 1.4. Вывод треугольника Паскаля в окно Command Prompt
Заключение
Уф-ф-ф! Вот вы и одолели базовые конструкции языка. Раз вы добрались до этого места, значит, умеете уже очень много. Вы можете написать программу на Java, отладить ее, устранив ошибки, и выполнить. Вы способны запрограммировать любой не слишком сложный вычислительный алгоритм, обрабатывающий числовые данные.
Теперь можно перейти к вопросам создания сложных производственных программ. Такие программы требуют тщательного планирования. Сделать это помогает объектноориентированное программирование, к которому мы теперь переходим. Но сначала проверьте свои знания и ответьте, пожалуйста, на контрольные вопросы.
Вопросы для самопроверки
1. РР· чего состоит программа РЅР° языке Java?
2. Как оформляется метод обработки информации в Java?
3. Каков заголовок у метода main() ?
4. Как записать комментарии к программе?
5. Что такое аннотация?
6. В каких системах счисления можно записывать целые константы?
7. Какое количество выражено числом 032?
8. Какое количество выражено числом 0х2С?
9. Как записать символ "наклонная черта"?
10. Как записать символ "обратная наклонная черта"?
11. Каков результат операции 3.45 % 2.4?
12. Что получится в результате операций 12 | 14 & 10?
13. Что даст в результате операция 3 << 4?
14. Можно ли записать циклы внутри условного оператора?
15. Можно ли использовать оператор continue в операторе варианта?
16. Можно ли использовать оператор break с меткой в операторе варианта?
17. Можно ли определить массив нулевой длины?
18. Как можно перебрать все элементы массива в порядке возрастания индексов?
19. Как перебрать все элементы массива в порядке убывания индексов?
20. Что случится, если индекс массива превысит его длину?
ГЛАВА 2
