- A variable holds a value, while an object reference variable points to the memory that holds the object.
- The short-circuit logical operators && and || operate only on boolean operands. For example, the expression
9&&7 will not compile. Understand the difference between short-circuit logical operators and bitwise
operators. - If the first expression of a && operator is false, the second expression is not evaluated, and if the first
expression of a || operator is true, the second expression is not evaluated.
Look Out
- Be on guard for words that are only slightly different from the Java keywords, such as synchronize instead of synchronized, implement instead of implements, and protect instead of protected.
- Whether an array stores primitive variables or object references, the array itself is always an object.
- It is illegal to include the array size in the array declaration.
- Division by zero generates a runtime ArithmeticException only if the operands are integers. In case of float and double, the result of division by zero is infinity.
- The result of the modulo operator always carries the sign of the first operand (i.e. the one before the operator);
you can ignore the sign of the second operand. - You cannot instantiate an enum by using the new operator.
Memorize
- Know the Java language keywords.
- Know the range of values for all primitive data types.
- All primitive data types except boolean and char are signed.
- The first character of an identifier must be a letter, a dollar sign ($), or an underscore (_). Characters other than the first character in an identifier may be a letter, a dollar sign, an underscore, or a digit.
]]>
- The method name and return type are mandatory in a method declaration. Even though you are not required to specify a modifier in a method declaration, the default modifier is assigned to the method, if you don’t declare one.
- A static variable belongs to the class and not to a particular instance of the class, and therefore is initialized when the class is loaded, and before the class is instantiated.
- Because a static method belongs to a class and not to a particular instance of the class, it cannot access the nonstatic methods and variables of the class in which it is defined.
- An instance of an inner class can only exist in an instance of the outer class, and has direct access to all the instance variables and methods of the outer instance.
- If you make a super call or a this call, it must be in the beginning of a constructor. That means you can make either a super call or a this call, but not both.
Look Out
- The variable-length parameters list must appear last in the parentheses of a method and it consists of a data type, three dots, and a name, in that order.
- A Java class cannot inherit from more than one class, but it can inherit from one class and one or more interfaces.
- The class that inherits from an interface must provide implementation for all the methods that are declared in the interface if the class is not abstract.
- An interface can extend another interface but it cannot implement another interface or a class.
Memorize
- If you do not provide any constructor for a class you write, the compiler provides the default constructor for that class. If you write at least one constructor for the class, the compiler provides no constructor.
- If you don not make a this or a super call in the beginning of a constructor, the compiler places a super() call there.
- You use the keyword extends to write a derived class that inherits from a parent class, and use the keyword implements to write a class that inherits from an interface.
- The methods in an interface are inherently public and abstract, and the variables in the interface are inherently public, final, and static.
]]>
For instance, according to the Java class library documentation, the read( ) method of java.io.InputStream returns "the next byte of data, or -1 if the end of the stream is reached." Upon reflection, this sounds suspicious. How is a -1 that appears as part of the stream data to be distinguished from a -1 indicating end of stream? In point of fact, the read( ) method does not return a byte; its signature shows that it returns an int:
1
public
聽
abstract
聽
int
聽read(聽)聽
throws
聽IOException
public
聽
abstract
聽
int
聽read(聽)聽
throws
聽IOException
This int is not a Java byte with a value between -128 and 127 but a more general unsigned byte with a value between 0 and 255. Hence, -1 can easily be distinguished from valid data values read from the stream.
JVM and byte, byte array
In fact, a single byte still takes up four bytes of space inside the Java virtual machine, but a byte array occupies only the amount of space it actually needs. The virtual machine includes special instructions for operating on byte arrays but does not include any instructions for operating on single bytes. They're just promoted to ints.
Input, Output, Reader and Writer
For the most part, these classes have methods that are extremely similar to the equivalent stream classes. Often the only difference is that a byte in the signature of a stream method becomes a char in the signature of the matching reader or writer method. For example, the java.io.OutputStream class declares these three write( ) methods:
The java.io.Writer class, therefore, declares these three write( ) methods:
As you can see, the signatures match except that in the latter two methods the byte array data has changed to a char array. There's also a less obvious difference not reflected in the signature. While the int passed to the OutputStream write( ) method is reduced modulo 256 before being output, the int passed to the Writer write( ) method is reduced modulo 65,536. This reflects the different ranges of chars and bytes.
java.io.Writer also has two more write( ) methods that take their data from a string:
public void write(String s)
throws IOException
public void write(String s, int offset, int length) throws IOException
Because streams don't know how to deal with character-based data, there are no corresponding methods in the java.io.OutputStream class.
Hello World!
聽
1聽聽
byte
[]聽hello聽
=
聽
{
72
,聽
101
,聽
108
,聽
108
,聽
111
,聽
32
,聽
87
,聽
111
,聽
114
,聽
108
,聽
100
,聽
33
,聽
10
,
13
}
;
2System.out.write(hello);
2
System.out.write(hello);
Powered by Zoundry
]]>