Expressions and Output

An escape sequence begins with a backslash and gives the next character a special meaning. It is written with two source-code characters but represents one character in the resulting text, so the printed result is shorter than the literal.

• A is not correct: this choice repeats the source characters instead of the resulting text, but each escape sequence is two source-code characters that represent one character.
• C is not correct: the quotation marks and the backslash are dropped here, while \" places a quotation mark and \\ places one backslash in the text.
• D is not correct: the code compiles, because each backslash begins one of the valid escape sequences rather than an invalid one.

The print method stays on the current line. The println method moves to a new line after displaying its value. Neither method inserts spaces automatically, so the characters run together until a println ends the line.

• A is not correct: this treats every output statement as ending its line, but print stays on the current line rather than moving to a new one.
• C is not correct: this ignores the println in the middle, which moves to a new line after displaying its value.
• D is not correct: this places the line break before B instead of after it, but the break comes from the statement that displays B.

A backslash in a String literal gives the next character a special meaning. Only certain escape sequences are valid, and an invalid one is a syntax error. Placing one backslash in the text requires \\.

• A is not correct: the backslash is not printed as itself, because it begins an escape sequence, and this one is invalid, so nothing is printed at all.
• B is not correct: the line never runs and prints nothing, since an invalid escape sequence is a syntax error rather than a silent removal.
• D is not correct: an ArithmeticException is a run-time error caused by integer division by 0, and this line contains no division.

Parentheses explicitly group an expression. Multiplication, division, and remainder bind more tightly than addition and subtraction. First determine the grouping from parentheses and precedence, then evaluate the grouped expression to reach the printed value.

• B is not correct: the second line has no parentheses, so multiplication binds more tightly than addition and the sum is not formed first.
• C is not correct: neither line produces 18, because the parenthesized sum 6 + 2 is multiplied by 3 and gives 24.
• D is not correct: the value 8 is only the parenthesized sum 6 + 2, and the multiplication by 3 still has to be applied.

An arithmetic expression may contain numeric values, variable names, operators, and parentheses. Producing a value does not automatically display it, so an expression and the statement that prints its value are different things.

• B is not correct: producing a value does not automatically display it, and a program must use an output statement for the value to be seen.
• C is not correct: an expression is code that evaluates to a value, which is not what a class is in a Java program.
• D is not correct: an arithmetic expression may contain numeric values, variable names, operators, and parentheses, so it is not limited to a single literal.

In 7 + 3 the operator is + and the operands are 7 and 3. The same reading applies to any arithmetic expression, where the symbol names the operation and the surrounding values are acted on.

• B is not correct: this reverses the two terms, because the symbol is the operator and the numeric values are the operands it acts on.
• C is not correct: the minus sign is an operator, so the expression does contain one and produces a value from its two operands.
• D is not correct: a String literal is a sequence of characters enclosed in double quotation marks, not something that a minus sign begins.

Operators on the same level are evaluated from left to right. The division happens first, and its result is then multiplied. Grouping from the right instead is valid only when explicit parentheses are written.

• A is not correct: this value comes from grouping the expression from the right, which is valid only when explicit parentheses are written around the last two operands.
• B is not correct: this is only the result of the division, and the multiplication on the same precedence level still has to be applied.
• D is not correct: this is the left operand by itself, and both the division and the multiplication still have to be evaluated.

Java performs integer division when both operands of / are int values. The result is an int, and any fractional part is discarded rather than rounded, so the result truncates toward zero.

• B is not correct: the value 2.75 keeps the fractional part, which requires at least one operand to be a double rather than two int values.
• C is not correct: the value 3 would be the rounded result, but integer division discards the fractional part instead of rounding it.
• D is not correct: the code compiles, because dividing one int by another is ordinary integer division and is not an error.

If at least one operand is a double, Java uses floating-point arithmetic and the division keeps its fractional part. Only when both operands are int values is the fractional part discarded.

• A is not correct: the value 2 is the integer-division result, which happens only when both operands are int values rather than one double.
• B is not correct: the value 2.0 discards the fractional part that floating-point arithmetic keeps, so it is not what this expression produces.
• D is not correct: an ArithmeticException is caused by integer division by 0, and neither operand here is 0.

The % operator produces the remainder after division. For nonnegative integers, when the left operand is smaller than a positive right operand, no complete group fits and the whole left operand is left over.

• A is not correct: a remainder of 0 would mean the division comes out evenly, but 8 is smaller than 13 and is left over entirely.
• B is not correct: the value 5 is the amount by which 13 exceeds 8, not the remainder that division leaves behind.
• D is not correct: the value 13 is the right operand, and a remainder is what is left over after division by that operand.

Multiplication, division, and remainder bind more tightly than addition and subtraction. First determine the grouping from precedence, then evaluate. Here the division is grouped by itself, and only its result takes part in the subtraction.

• A is not correct: this comes from subtracting before dividing, but precedence groups the division first unless explicit parentheses say otherwise.
• C is not correct: this is only the subtraction 18 - 8, and it ignores the division that precedence requires to be evaluated first.
• D is not correct: this is the right operand of the division by itself, and the subtraction from 18 still has to happen.

A String literal is a sequence of characters enclosed in double quotation marks, so a quotation mark inside the text needs an escape sequence. The two source-code characters represent one character in the resulting text.

• A is not correct: a new line in the text comes from \n, which is a different escape sequence from the one shown here.
• B is not correct: the escape sequences in this topic place a quotation mark, one backslash, or a new line in the text.
• D is not correct: the sequence \\ places one backslash in the text, and two source-code characters represent a single character rather than two.

Integer division by 0 is not reported when the program is compiled. It happens while the program runs, and the resulting ArithmeticException interrupts execution rather than producing a value.

• A is not correct: the expression produces no value at all, because execution is interrupted instead of returning 0 to the output statement.
• B is not correct: the compiler accepts the division operator, and the problem appears while the program runs rather than when it is compiled.
• D is not correct: Java does not replace the divisor with 1, because integer division by 0 causes an ArithmeticException instead.