Thinking in Java——笔记(3)

Operator

---

Using Java operators

• Some operators change the value of an operand. This is called a side effect.
• Almost all operators work only with primitives. The exceptions are ‘=‘, ‘==‘ and ‘!=‘, which work with all objects.

Precedence

• You should use parentheses to make the order of evaluation explicit.

Assignment

• An rvalue is any constant, variable, or expression that produces a value, but an lvalue must be a distinct, named variable.
• When you assign primitives, you copy the contents from one place to another.
• When you assign “from one object to another,” you’re actually copying a reference from one place to another.
• Because you’ve assigned a reference, changing the t1 object appears to change the t2 object as well! This is because both t1 and t2 contain the same reference, which is pointing to the same object.
• Manipulating the fields within objects is messy and goes against good object-oriented design principles.
• Aliasing will also occur when you pass an object into a method.

Mathematical operators

• For pre-increment and pre-decrement (i.e., ++a or --a), the operation is performed and the value is produced. For post-increment and post-decrement (i.e., a++ or a--), the value is produced, then the operation is performed.
• For the prefix form, you get the value after the operation has been performed, but with the postfix form, you get the value before the operation is performed.

Relational operators

• Equivalence and nonequivalence work with all primitives, but the other comparisons won’t work with type boolean.
• While the contents of the objects are the same, the references are not the same. The operators == and != compare object references.
• The default behavior of equals( ) is to compare references. So unless you override equals( ) in your new class you won’t get the desired behavior.
• Most of the Java library classes implement equals( ) so that it compares the contents of objects instead of their references.

Logical operators

• You can apply AND, OR, or NOT to boolean values only. You can’t use a non-boolean as if it were a boolean in a logical expression as you can in C and C++.
• A boolean value is automatically converted to an appropriate text form if it is used where a String is expected.
• The expression will be evaluated only until the truth or falsehood of the entire expression can be unambiguously determined.
• The latter parts of a logical expression might not be evaluated.

Literals

• A trailing character after a literal value establishes its type.
• If you try to initialize a variable with a value bigger than it can hold, the compiler will give you an error message.

Exponential notation

• When the FORTRAN programming language was invented, they decided that e would mean “ten to the power”.
• The compiler normally takes exponential numbers as doubles.

Bitwise operators

• Because bits are “small”, there is only one character in the bitwise operators.
• For booleans, the bitwise operators have the same effect as the logical operators except that they do not short circuit.

Shift operators

• If you shift a char, byte, or short, it will be promoted to int before the shift takes place, and the result will be an int.
• There is a problem with the unsigned right shift combined with assignment. If you use it with byte or short, you don’t get the correct results. Instead, these are promoted to int and right shifted, but then truncated as they are assigned back into their variables, so you get -1 in those cases.

Ternary if-else operator

• You should be somewhat wary of using it on an everyday basis—it’s easy to produce unreadable code.
• It’s generally warranted when you’re setting a variable to one of two values.

String operator + and +=

• Java programmers cannot implement their own overloaded operators like C++ and C# programmers can.
• If an expression begins with a String, then all operands that follow must be Strings.
• The string conversion does not depend on what comes first.
• You will sometimes see an empty String followed by a + and a primitive as a way to perform the conversion without calling the more cumbersome explicit method.

Common pitfalls when using operators

• Leave out the parentheses when you are even the least bit uncertain about how an expression will evaluate.
• Bitwise AND and OR use one of the characters (& or |) while logical AND and OR use two (&& and ||).

Casting operators

• Java will automatically change one type of data into another when appropriate.
• It’s possible to perform a cast on a numeric value as well as on a variable.
• You are allowed to use superfluous casts to make a point or to clarify your code.
• When you perform a so-called narrowing conversion , you run the risk of losing information.
• Java allows you to cast any primitive type to any other primitive type, except for boolean, which doesn’t allow any casting at all.
• Class types do not allow casting. To convert one to the other, there must be special methods.

Truncation and rounding

• Casting from a float or double to an integral value always truncates the number.
• If instead you want the result to be rounded, use the round( ) methods.

Promotion

• In general, the largest data type in an expression is the one that determines the size of the result of that expression.

Java has no “sizeof”

• The most compelling reason for sizeof( ) in C and C++ is for portability.
• The programmer must discover how big those types are when performing operations that are sensitive to size.
• Java does not need a sizeof( ) operator for this purpose, because all the data types are the same size on all machines.