где ор — арифметический или логический оператор, применяемый вместе с оператором присваивания.
Ниже перечислены укороченные операторы присваивания для арифметических и логических операций.+=-=*=/=%=&=|=^=
Каждый из перечисленных выше операторов состоит из двух знаков, обозначающих арифметическую или логическую операцию, а также операцию присваивания. Поэтому их часто еще называют составными операторами присваивания.
У составных операторов присваивания имеются два главных преимущества. Во-первых, они более компактны, чем их неукороченные эквиваленты. И во-вторых, дают более эффективный исполняемый код, поскольку левый операнд этих операторов вычисляется только один раз. Именно по этим причинам составные операторы присваивания чаще всего применяются в программах, профессионально написанных на Java.Преобразование типов при присваивании
При написании программ очень часто возникает потребность в присваивании значения, хранящегося в переменной одного типа, переменной другого типа. Например, значение int, возможно, потребуется присвоить переменной float, как показано ниже.int i;float f;i = 10;f = i; // присвоить значение переменной типа int переменной типа float
Если типы данных являются совместимыми, значение из правой части оператора присваивания автоматически преобразуется к типу данных в левой его части. Так, в приведенном выше фрагменте кода значение переменной i преобразуется в тип float, а затем присваивается переменной f. Но ведь Java — язык со строгим контролем типов, и далеко не все типы данных в нем совместимы, поэтому неявное преобразование типов выполняется не всегда. В частности, типы boolean и int не являются совместимыми.
Автоматическое преобразование типов в операции присваивания выполняется при соблюдении следующих условий:
оба типа являются совместимыми;
целевой тип обладает более широким диапазоном допустимых значений, чем исходный тип.
Если оба перечисленных выше условия соблюдаются, происходит расширяющее преобразование типов. Например, диапазона значений, допустимых для типа int, совершенно достаточно, чтобы представить любое значение типа byte, а кроме того, оба эти типа данных являются целочисленными. Поэтому и происходит автоматическое преобразование типа byte в тип int.
С точки зрения расширяющего преобразования типов целочисленные типы и типы с плавающей точкой совместимы друг с другом. Например, приведенная ниже программа написана корректно, поскольку преобразование типа long в тип double является расширяющим и выполняется автоматически.// Демонстрация автоматического преобразования типа long в тип double,class LtoD { public static void main(String args[]) { long L; double D; L = 100123285L; // Автоматическое преобразование типа long в тип double. D = L; System.out.println("L and D: " + L + " " + D); }}
В то же время тип double не может быть автоматически преобразован в тип long, поскольку такое преобразование уже не является расширяющим. Следовательно, приведенный ниже вариант той же самом программы оказывается некорректным.// *** Эта программа не подлежит компиляции. ***class LtoD { public static void main(String args[]) { long L; double D; D = 100123285.0; // Тип double не преобразуется автоматически в тип long. L = D; // Ошибка!!! System.out.println("L and D: " + L + " " + D) ; }}
Автоматическое преобразование числовых типов в тип char или boolean не производится. Кроме того, типы char и boolean несовместимы друг с другом. Тем не менее переменной char может быть присвоено значение, представленное целочисленным литералом.Приведение несовместимых типов
Несмотря на всю полезность неявных автоматических преобразований типов, они неспособны удовлетворить все потребности в программировании, поскольку допускают лишь расширяющие преобразования совместимых типов. А во всех остальных случаях приходится обращаться к приведению типов. Приведение — это команда компилятору преобразовать результат вычисления выражения в указанный тип. А для этого требуется явное преобразование типов. Ниже показана общая форма приведения типов.(целевой_тип) выражение
где целевой_тип обозначает тот тип, в который желательно преобразовать указанное выражение. Так, если требуется привести значение, возвращаемое выражением х / у, к типу int, это можно сделать следующим образом:double х, у;// ...(int) (х / у)
В данном случае приведение типов обеспечит преобразование результатов выполнения выражения в тип int, несмотря на то, что переменные х и у принадлежат к типу double. Выражение х / у следует непременно заключить в круглые скобки, иначе будет преобразован не результат деления, а только значение переменной х. Приведение типов в данном случае требуется потому, что автоматическое преобразование типа double в тип int не выполняется.
Если приведение типов приводит к сужающему преобразованию, то часть информации может быть потеряна. Например, в результате приведения типа long к типу int часть информации потеряется, если значение типа long окажется больше диапазона представления чисел для типа int, поскольку старшие разряды этого числового значения отбрасываются. Когда же значение с плавающей точкой приводится к целочисленному, в результате усечения теряется дробная часть этого числового значения. Так, если присвоить значение 1,23 целочисленной переменной, то в результате в ней останется лишь целая часть исходного числа (1), а дробная его часть (0,23) будет потеряна.
Ниже приведен пример программы, демонстрирующий некоторые виды преобразований, требующие явного приведения типов.// Демонстрация приведения типов,class CastDemo { public static void main(String args[]) { double x, y; byte b; int i; char ch; x = 10.0; У = 3.0; // В данном случае теряется дробная часть числа. i = (int) (х / у); // привести тип double к типу int System.out.println("Integer outcome of x / y: " + i) ; i = 100; // А в этом случае данные не теряются. Тип byte может // содержать значение 100. Ъ = (byte) i; System.out.println ("Value of b: " + b) ; i = 257; //На этот раз данные теряются. Тип byte не может // содержать значение 257. b = (byte) i; System.out.println("Value of b: " + b); b = 88; // Представление символа X в коде ASCII. //И снова требуется явное приведение несовместимых типов. ch = (char) b; System.out.println("ch: " + ch); }}
Выполнение этой программы дает следующий результат:Integer outcome of х / у: 3Value of b: 100Value of b: 1ch: X
В данной программе приведение выражения (х / у) к типу int означает потерю дробной части числового значения результата деления. Когда переменной b присваивается значение 100 из переменной i, данные не теряются, поскольку диапазон допустимых значений у типа byte достаточен для представления этого значения. Далее при попытке присвоить переменной b значение 257 снова происходит потеря данных, поскольку значение 257 оказывается за пределами диапазона допустимых значений для типа byte. И наконец, когда переменной char присваивается содержимое переменной типа byte, данные не теряются, но явное приведение типов все же требуется.Предшествование операторов
В табл. 2.3 приведен порядок предшествования всех операторов в Java: от самого высокого до самого низкого. В эту таблицу включен ряд операторов, рассматриваемых далее в этой книге. Формально разделители [], () и . могут действовать как операторы, и в этом случае они будут иметь наивысший порядок предшествования.
Таблица 2.3. Предшествование операторов в JavaНаивысший порядок++ (постфиксный)-- (постфиксный)++ (префиксный)-- (префиксный)~!+ (унарный плюс)- (унарный минус)(приведение типов)*/%+->><<<<<>>=<<=instanceof==!=&^|&&||?:=op=
Пример для опробования 2.2.Отображение таблицы истинности для логических операторов
В этом проекте предстоит создать программу, которая отображает таблицу истинности для логических операторов Java. Для удобства восприятия отображаемой информации следует выровнять столбцы таблицы. В данном проекте используется ряд языковых средств, рассмотренных ранее в этой главе, включая управляющие последовательности и логические операторы, а также демонстрируются отличия в предшествовании арифметических и логических операторов.
Последовательность действий
Создайте новый файл LogicalOpTable. java.
Для того чтобы обеспечить выравнивание столбцов таблицы, в каждую выводимую строку следует ввести символы \t. В качестве примера ниже приведен вызов метода println () для отображения заголовков таблицы. System.out.println(nP\tQ\tAND\tOR\tXOR\tNOT");
Для того чтобы сведения об операторах располагались под соответствующими заголовками, в каждую последующую строку таблицы должны быть введены символы табуляции.
Введите в файл LogicalOpTable . j ava исходный код программы, как показано ниже.// Пример для опробования 2.2.// Отображение таблицы истинности для логических операторов,class LogicalOpTable { public static void main(String args[]) { boolean p, q; System.out.println(MP\tQ\tAND\tOR\tXOR\tNOT"); p = true; q = true; System.out.print(p + "\tM + q +"\tn); System.out.print((p&q) + "\t" + (plq) + "\t"); System.out.println((pAq) + "\t" + (Ip)); p = true; q = false; System.out.print(p + "\t" + q +"\t"); System.out.print((p&q) + "\t" + (plq) + "\t"); System.out.println((pAq) + "\t" + (!p)); p = false; q = true; System, out .print (p + n\t" + q +"\t,f); System.out.print((p&q) + "\t" + (plq) + "\t"); System.out.println((pAq) + M\t" + (!p)); p = false; q = false; System.out.print(p + "\t" + q +"\t"); System.out.print((p&q) + "\t" + (plq) + "\t"); System.out.println((pAq) + "\t" + (!p)); }}
Обратите внимание на то, что в операторах с вызовами метода println () логические операторы заключены в круглые скобки. Эти скобки необходимы для соблюдения предшествования операторов. В частности, арифметический оператор + имеет более высокий порядок предшествования, чем логические операторы.
Скомпилируйте программу и запустите ее на выполнение, чтобы вывести на экран следующий результат:P Q AND OR XOR NOTtrue true true true false falsetrue false false true true falsefalse true false true true truefalse false false false false true
Попробуйте видоизменить программу таким образом, чтобы вместо логических значений true и false отображались значения 1 и 0. Это потребует больших усилий, чем кажется на первый взгляд!Выражения
Операторы, переменные и литералы являются составными частями выражений. Выражением в Java может стать любое допустимое сочетание этих составных частей. Выражения должны быть уже знакомы вам по предыдущим примерам программ. Более того, вы изучали их в школьном курсе алгебры. Но некоторые их особенности все же нуждаются в обсуждении.Преобразование типов в выражениях типов в выражениях
В выражении можно свободно употреблять два или несколько типов данных, при условии их совместимости друг с другом. Например, в одном выражении допускается применение типов short и long, поскольку оба типа являются числовыми. Когда в выражении употребляются разные типы данных, они преобразуются в один и тот же тип по принятым в Java правилам продвижения типов.
Сначала все значения типа char, byte и short продвигаются к типу int. Затем все выражение продвигается к типу long, если хотя бы один из его операндов принадлежит к типу long. Далее все выражение продвигается к типу float, если хотя бы один из операндов относится к типу float. А если какой-нибудь из операндов относится к типу double, то результат также относится к типу double.
Очень важно иметь в виду, что правила продвижения типов применяются только к значениям, над которыми выполняются действия по мере вычисления выражения. Так, если значение переменной типа byte при вычислении выражения продвигается к типу int, за пределами выражения эта переменная будет по-прежнему относиться к типу byte. Следовательно, продвижение типов затрагивает только вычисление выражения.
Но продвижение типов может иногда привести к неожиданным результатам. Если, например, в арифметической операции используются два значения типа byte, то про исходит следующее. Сначала операнды типа byte продвигаются к типу int. А затем выполняется операция, дающая результат типа int. Следовательно, результат выполнения операции, в которой участвуют два значения типа byte, будет иметь тип int. Но ведь это не тот результат, который можно было бы с очевидностью предположить. Рассмотрим следующий пример программы:// Неожиданный результат продвижения типов!class PromDemo { public static void main(String args[]) { byte b; int i; b = 10; // В данном случае приведение типов не требуется, так как // результат вычисления выражения уже относится к типу int. i = b * b; b = 10; // А в этом случае приведение типов требуется для // присваивания значения int переменной типа byte! b = (byte) (b * Ь); // cast needed!! System.out.println("i and b: " + i + " " + b); }}
Как ни странно, но когда результат вычисления выражения bb присваивается обратно переменной Ь, то возникает потребность в приведении к типу byte! Объясняетсяэто тем, что в выражении bb значение переменной b продвигается к типу int и поэтому не может быть присвоено переменной типа byte без приведения типов. Имейте это обстоятельство в виду, если получите неожиданное сообщение об ошибке несовместимости типов в выражениях, которые, на первый взгляд, кажутся совершенно правильными.
Аналогичная ситуация возникает при выполнении операций с символьными операндами. Например, в следующем фрагменте кода требуется обратное приведение к типу char, поскольку операнды chi и ch2 в выражении продвигаются к типу int:char chi = 'a', ch2 = ' b';chi = (char) (chi + ch2);
Без приведения типов результат сложения операндов chi и ch2 будет иметь тип int, и поэтому его нельзя присвоить переменной типа char.
Приведение типов необходимо не только при присваивании значения переменной. Рассмотрим в качестве примера следующую программу. В ней приведение типов выполняется для того, чтобы дробная часть числового значения типа double не была утеряна. В противном случае операция деления будет выполняться над целыми числами.// Приведение типов для правильного вычисления выражения,class UseCast { public static void main(String args[]) { int i; for(i = 0; i < 5; i++) { System, out .println (i + " / 3: 11 + i / 3) ; System.out.println(i + " / 3 with fractions: " + (double) i / 3); System.out.println(); } }}
Ниже приведен результат выполнения данной программы.0 / 3: 00/3 with fractions: 0.01 / 3: 01/3 with fractions: 0.33333333333333332 / 3: 02/3 with fractions: 0.66666666666666663/3: 13/3 with fractions: 1.04 / 3: 14/3 with fractions: 1.3333333333333333Пробелы и круглые скобки
Для того чтобы сделать выражения в коде Java более удобными для восприятия, в них можно использовать символы табуляции и пробелы. Например, ниже приведены два варианта одного и того же выражения, но второй вариант читается гораздо легче.х=10/у*(127/х) ;х = 10 / у * (127/х);
Круглые скобки повышают порядок предшествования содержащихся в них операций. (Аналогичное правило применяется и в алгебре.) Избыточные скобки допустимы. Они не приводят к ошибке и не замедляют выполнение программы. В некоторых случаях лишние скобки даже желательны. Они поясняют порядок вычисления выражения как для вас, так и для тех, кто будет разбирать исходный код вашей программы. Какое из приведенных ниже двух выражений воспринимается легче?х = y/3-34*temp+127 ;х = (у/3) - (34*temp) + 127;Упражнение для самопроверки по материалу главы 2
Почему в Java строго определены диапазоны допустимых значений и области действия простых типов?
Что собой представляет символьный тип в Java и чем он отличается от символьного типа в ряде других языков программирования?
Переменная типа boolean может иметь любое значение, поскольку любое ненулевое значение интерпретируется как истинное. Верно или неверно?
Допустим, результат выполнения программы выглядит следующим образом: One Two Three Напишите строку кода с вызовом метода println (), где этот результат выводится в одной символьной строке.