Review Questions

1.8

What command in the Java 2 SDK should be used to compile the following code contained in a file called SmallProg.java ?

public class SmallProg {
    public static void main(String[] args) { System.out.println("Good luck!"); }
}

Select the one correct answer.

java SmallProg
javac SmallProg
java SmallProg.java
javac SmallProg.java
java SmallProg main

1.9

What command in the Java 2 SDK should be used to execute the main() method of a class named SmallProg ?

Select the one correct answer.

java SmallProg
javac SmallProg
java SmallProg.java
java SmallProg.class
java SmallProg.main()

Chapter Summary

The following topics were discussed in this chapter:

basic concepts in OOP, and how they are supported in Java
essential elements of a Java application
compiling and running Java applications

Programming Exercises

1.1

Modify the program from Example 1.4 to use the PrintableCharStack class, rather than the CharStack class. Utilize the printStackElements() method from the PrintableCharStack class. Is the new program behavior-wise any different from Example 1.4?

Chapter 2. Language Fundamentals

Exam Objectives

Identify correctly constructed package declarations, import statements, class declarations (of all forms, including inner classes), interface declarations, method declarations (including the main method that is used to start execution of a class), variable declarations, and identifiers.
- For defining and using packages, see Section 4.6 .
- For class declarations, see Section 4.2 .
- For nested classes, see Chapter 7 .
- For interface declarations, see Section 6.4 .
- For method declarations, see Section 4.3 .
Identify classes that correctly implement an interface where that interface is either java.lang.Runnable or a fully specified interface in the question.
- For interface implementation, see Section 6.4 .
- For implementation of java.lang.Runnable , see Section 9.3 .
State the correspondence between index values in the argument array passed to a main method and command line arguments.
- See Section 3.23 .
Identify all Java programming language keywords. Note: There will not be any questions regarding esoteric distinctions between keywords and manifest constants.
State the effect of using a variable or array element of any kind, when no explicit assignment has been made to it.
- For array elements, see Section 4.1 .
State the range of all primitive data types, and declare literal values for String and all primitive types using all permitted formats, bases and representations.
- See also Appendix G .

Supplementary Objectives

State the wrapper classes for primitive data types.

2.1 Basic Language Elements

Like any other programming language, the Java programming language is defined by grammar rules that specify how syntactically legal constructs can be formed using the language elements, and by a semantic definition that specifies the meaning of syntactically legal constructs.

Lexical Tokens

The low-level language elements are called lexical tokens (or just tokens for short) and are the building blocks for more complex constructs. Identifiers, numbers , operators, and special characters are all examples of tokens that can be used to build high-level constructs like expressions, statements, methods , and classes.

Identifiers

A name in a program is called an identifier . Identifiers can be used to denote classes, methods, variables , and labels.

In Java an identifier is composed of a sequence of characters, where each character can be either a letter , a digit , a connecting punctuation (such as underscore _ ), or any currency symbol (such as $ , ¢ , , or & pound ; ). However, the first character in an identifier cannot be a digit. Since Java programs are written in the Unicode character set (see p. 23), the definitions of letter and digit are interpreted according to this character set.

Identifiers in Java are case sensitive, for example, price and Price are two different identifiers.

Examples of Legal Identifiers:

number, Number, sum_$, bingo, $$_100, ml, gr

Examples of Illegal Identifiers:

48chevy, all@hands, grand-sum

The name 48chevy is not a legal identifier as it starts with a digit. The character @ is not a legal character in an identifier. It is also not a legal operator so that all@hands cannot not be interpreted as a legal expression with two operands. The character - is also not a legal character in an identifier. However, it is a legal operator so grand-sum could be interpreted as a legal expression with two operands.

Keywords

Keywords are reserved identifiers that are predefined in the language and cannot be used to denote other entities. All the keywords are in lowercase, and incorrect usage results in compilation errors.

Keywords currently defined in the language are listed in Table 2.1. In addition, three identifiers are reserved as predefined literals in the language: the null reference and the Boolean literals true and false (see Table 2.2). Keywords currently reserved, but not in use, are listed in Table 2.3. All these reserved words cannot be used as identifiers. The index contains references to relevant sections where currently defined keywords are explained.

Table 2.1. Keywords in Java

`abstract`	`default`	`implements`	`protected`	`throw`
`assert`	`do`	`import`	`public`	`throws`
`boolean`	`double`	`instanceof`	`return`	`transient`
`break`	`else`	`int`	`short`	`try`
`byte`	`extends`	`interface`	`static`	`void`
`case`	`final`	`long`	`strictfp`	`volatile`
`catch`	`finally`	`native`	`super`	`while`
`char`	`float`	`new`	`switch`
`class`	`for`	`package`	`synchronized`
`continue`	`if`	`private`	`this`

Table 2.2. Reserved Literals in Java

null

true

false

Table 2.3. Reserved Keywords not Currently in Use

const

goto

Literals

A literal denotes a constant value, that is, the value a literal represents remains unchanged in the program. Literals represent numerical (integer or floating-point), character, boolean or string values. In addition, there is the literal null that represents the null reference.

Table 2.4. Examples of Literals

Integer	2000 0 -7
Floating-point	3.14 -3.14 .5 0.5
Character	'a' 'A' '0' ':' '-' ')'
Boolean	true false
String	"abba" "3.14" "for" "a piece of the action"

Integer Literals

Integer data types are comprised of the following primitive data types: int , long , byte , and short (see Section 2.2).

The default data type of an integer literal is always int , but it can be specified as long by appending the suffix L (or l ) to the integer value. Without the suffix, the long literals 2000L and 0l will be interpreted as int literals. There is no direct way to specify a short or a byte literal.

In addition to the decimal number system, integer literals can also be specified in octal ( base 8 ) and hexadecimal ( base 16 ) number systems. Octal and hexadecimal numbers are specified with and 0x (or 0X ) prefix respectively. Examples of decimal, octal and hexadecimal literals are shown in Table 2.5. Note that the leading (zero) digit is not the uppercase letter O . The hexadecimal digits from a to f can also be specified with the corresponding uppercase forms ( A to F ). Negative integers (e.g. -90 ) can be specified by prefixing the minus sign ( - ) to the magnitude of the integer regardless of number system (e.g., -0132 or -0X5A ). Number systems and number representation are discussed in Appendix G. Java does not support literals in binary notation.

Table 2.5. Examples of Decimal, Octal, and Hexadecimal Literals

Decimal	Octal	Hexadecimal
`8`	`010`	`0x8`
`10L`	`012L`	`0XaL`
`16`	`020`	`0x10`
`27`	`033`	`0x1B`
`90L`	`0132L`	`0x5aL`
`-90`	`-0132`	`-0X5A`
`2147483647` (i.e., 2 ³¹ `-1` )	`017777777777`	`0x7fffffff`
`-2147483648` (i.e., -2 ³¹ )	`-020000000000`	`-0x80000000`
`1125899906842624L` (i.e., 2 ⁵⁰ )	`040000000000000000L`	`0x4000000000000L`

Floating-point Literals

Floating-point data types come in two flavors: float or double .

The default data type of a floating-point literal is double , but it can be explicitly designated by appending the suffix D (or d ) to the value. A floating-point literal can also be specified to be a float by appending the suffix F (or f ).

Floating-point literals can also be specified in scientific notation, where E (or e ) stands for Exponent . For example, the double literal 194.9E-2 in scientific notation is interpreted as 194.9*10 ^-2 (i.e., 1.949 ).

Examples of `double` Literals

0.0       0.0d       0D
0.49      .49        .49D
49.0      49.        49D
4.9E+1    4.9E+1D    4.9e1d   4900e-2  .49E2

Examples of `float` Literals

0.0F      0f
0.49F     .49F
49.0F     49.F       49F
4.9E+1F   4900e-2f   .49E2F

Note that the decimal point and the exponent are optional and that at least one digit must be specified.

Boolean Literals

The primitive data type boolean represents the truth-values true or false that are denoted by the reserved literals true or false , respectively.

Character Literals

A character literal is quoted in single-quotes ( ' ). All character literals have the primitive data type char .

Characters in Java are represented by the 16-bit Unicode character set, which subsumes the 8-bit ISO-Latin-1 and the 7-bit ASCII characters. In Table 2.6, note that digits ( to 9 ), upper-case letters ( A to Z ), and lower-case letters ( a to z ) have contiguous Unicode values. Any Unicode character can be specified as a four-digit hexadecimal number (i.e., 16 bits) with the prefix \u .

Table 2.6. Examples of Unicode Values

Character Literal	Character Literal using Unicode value	Character
`' '`	`'\u0020'`	`Space`
`'0'`	`'\u0030'`
`'1'`	`'\u0031'`	`1`
`'9'`	`'\u0039'`	`9`
`'A'`	`'\u0041'`	`A`
`'B'`	`'\u0042'`	`B`
`'Z'`	`'\u005a'`	`Z`
`'a'`	`'\u0061'`	`a`
`'b'`	`'\u0062'`	`b`
`'z'`	`'\u007a'`	`z`
`' ‘'`	`'\u0084'`	`‘`
`' '`	`'\u008c'`
`' '`	`'\u00a7'`

Escape Sequences

Certain escape sequences define special character values as shown in Table 2.7. These escape sequences can be single-quoted to define character literals. For example, the character literals '\t' and '\u0009' are equivalent. However, the character literals ' \u000a' and ' \u000d' should not be used to represent newline and carriage return in the source code. These values are interpreted as line-terminator characters by the compiler, and will cause compile time errors. One should use the escape sequences '\n' and '\r' , respectively, for correct interpretation of these characters in the source code.

Table 2.7. Escape Sequences

Escape Sequence	Unicode Value	Character
`\b`	`\u0008`	Backspace (BS)
`\t`	`\u0009`	Horizontal tab (HT or TAB)
`\n`	`\u000a`	Linefeed (LF) a.k.a., Newline (NL)
`\f`	`\u000c`	Form feed (FF)
`\r`	`\u000d`	Carriage return (CR)
`\'`	`\u0027`	Apostrophe-quote
`\"`	`\u0022`	Quotation mark
`\\`	`\u005c`	Backslash

We can also use the escape sequence \ ddd to specify a character literal by octal value, where each digit d can be any octal digit ( “ 7 ), as shown in Table 2.8. The number of digits must be three or fewer, and the octal value cannot exceed \377 , that is, only the first 256 characters can be specified with this notation.

Table 2.8. Examples of Escape Sequence `\ddd`

Escape Sequence `\ddd`	Character Literal
`'\141'`	`'a'`
`'\46'`	`'&'`
`'\60'`	`'0'`

String Literals

A string literal is a sequence of characters, which must be quoted in quotation marks and which must occur on a single line. All string literal are objects of the class String (see Section 10.5, p. 407).

Escape sequences as well as Unicode values can appear in string literals:

"Here comes a tab.\t And here comes another one\u0009!                    (1)
"What's on the menu?"                                                     (2)
"\"String literals are double-quoted.\""                                  (3)
"Left!\nRight!"                                                           (4)

In (1), the tab character is specified using the escape sequence and the Unicode value respectively. In (2), the single apostrophe need not be escaped in strings, but it would be if specified as a character literal( '\'' ). In (3), the double apostrophes in the string must be escaped. In (4), we use the escape sequence \n to insert a newline. Printing these strings would give the following result:

Here comes a tab.    And here comes another one    !
What's on the menu?
"String literals are double-quoted."
Left!
Right!

One should also use the string literals "\n" and "\r" , respectively, for correct interpretation of the characters " \u000a" and " \u000d" in the source code.

White Spaces

A white space is a sequence of spaces, tabs, form feeds, and line terminator characters in a Java source file. Line terminators can be newline, carriage return, or carriage return-newline sequence.

A Java program is a free-format sequence of characters that is tokenized by the compiler, that is, broken into a stream of tokens for further analysis. Separators and operators help to distinguish tokens, but sometimes white space has to be inserted explicitly as separators. For example, the identifier classRoom will be interpreted as a single token, unless white space is inserted to distinguish the keyword class from the identifier Room.

White space aids not only in separating tokens, but also in formatting the program so that it is easy for humans to read. The compiler ignores the white spaces once the tokens are identified.

Comments

A program can be documented by inserting comments at relevant places. These comments are for documentation purposes and are ignored by the compiler.

Java provides three types of comments to document a program:

A single-line comment : // ... to the end of the line
A multiple-line comment : /* ... */
A documentation (Javadoc) comment : /** ... */

Single-line Comment

All characters after the comment-start sequence // through to the end of the line constitute a single-line comment .

// This comment ends at the end of this line.
int age;        // From comment-start sequence to the end of the line is a comment.

Multiple-line Comment

A multiple-line comment , as the name suggests, can span several lines. Such a comment starts with /* and ends with */ .

/*  A comment
    on several
    lines.
*/

The comment-start sequences ( // , /* , /** ) are not treated differently from other characters when occurring within comments, and are thus ignored. This means trying to nest multiple-line comments will result in compile time error:

/*  Formula for alchemy.
    gold = wizard.makeGold(stone);
    /* But it only works on Sundays. */
*/

The second occurrence of the comment-start sequence /* is ignored. The last occurrence of the sequence */ in the code is now unmatched, resulting in a syntax error.

Documentation Comment

A documentation comment is a special-purpose comment that when placed before class or class member declarations can be extracted and used by the javadoc tool to generate HTML documentation for the program. Documentation comments are usually placed in front of classes, interfaces, methods and field definitions. Groups of special tags can be used inside a documentation comment to provide more specific information. Such a comment starts with /** and ends with */ :

/**
 *  This class implements a gizmo.
 *  @author K.A.M.
 *  @version 2.0
 */

For details on the javadoc tool, see the documentation for the tools in the Java 2 SDK.

Buy on amazon.com >>

Mughal K., Rasmussen R.

<< Previous page

Table of contents

Next page >>

Flylib.com

Category list

Similar pages

Review Questions