Objectives
You are going to be asked to answer exam questions in exam regarding the following subjects.
So be sure that you understand everything. After reading each article,
I suggest you to write and compile small Java programs.
I believe that practice is always better than theory. At the exam, you will be
asked about the following topics [2].
- Identifiers and Keywords
- Primitive Types
- Literals
- Arrays
- Variable Types and Initialization
If you have any questions after studying this document, do not hesitate to
drop me an e-mail, and I will try to clarify
things as best as I can.
You can read more information about SCJP certification from the
SJCP Web page [2], and you can download the .pdf file called “Sun Certified Programmer
for Java 2 Platform
Success Guide” [3].
Identifiers and Keywords
Identifiers are used by programmers to give meaningful names used by the Java language
to uniquely identify classes, methods, and variables.
An identifier must begin with a letter, an underscore ‘_’, or a dollar sign ‘$’.
Subsequent characters can be any of these plus digits between 0 and 9. An identifier
cannot begin with a digit; doing so will cause a compile-time exception.
Identifiers are case sensitive and cannot have the same name as keywords or reserved words.
// legal | |
// legal | |
// legal | |
// illegal | |
// illegal. This is a keyword. | |
// legal (Java is case sensitive) | |
| // legal |
// legal. | |
// illegal. |
A Unicode character, which can appear anywhere, can be used in a Java source file.
Since u0062 is a valid Unicode character, the given example u0062ook is a valid Java
identifier. The Unicode letter u0062 substitutes for the letter ‘b’.
Keywords and reserved words are predefined names used by the Java language, which
we cannot use as identifiers. The following table shows the list of Java keywords
and reserved words.
Java Keywords and Reserved Words |
|||||
abstract |
boolean |
break |
byte |
case |
catch |
char |
class |
const 1 |
continue |
default |
do |
double |
else |
extends |
final |
finally |
float |
for |
goto 1 |
if |
implements |
import |
instanceof |
int |
interface |
long |
native |
new |
package |
private |
protected |
public |
return |
short |
static |
strictfp |
super |
switch |
synchronized |
this |
throw |
throws |
transient |
try |
void |
volatile |
while
|
true 2 |
false 2 |
null 2 |
1 ‘goto’ and ‘cost’ are reserved words but they do not have any use
in Java. Since ‘goto’ and ‘cost’ are reserved words, they cannot be used as identifiers.
2 ‘true, ‘false’, ‘null’ might appear to be keywords but they are technically
literals [1][’3.10.3]. ‘true, ‘false’ are Boolean literals and ‘null’ is the null literal
(they cannot be used as identifiers).
Primitive Types and their Wrapper Classes
Java has eight primitive types; each primitive type has a matching wrapper class.
A variable declared as type primitive cannot store an object reference.
The primitive types are used to store primitive values.
All numeric types are signed, except ‘boolean’ and ‘char’. The ‘boolean’ literal has
exactly two values: ‘true’, and ‘false’.
There are two kinds of numeric types: the integral and the floating-point types.
The integral types are:
- byte
- short
- int
- long
- char
The floating-point types, complying with IEEE 754 specification, are:
- float
- double
Float and Double are wrapper classes of the float and double primitive types.
Three constant values -NaN, POSITIVE_INFINITY, and NEGATIVE_INFINITY- have been defined in each wrapper class
in order to define results of undefined mathematical operations (non-numerical values).
The following table shows these values
- Float.NaN
- Float.POSITIVE_INFINITY
- Float.NEGATIVE_INFINITY
- Double.NaN
- Double.POSITIVE_INFINITY
- Double.NEGATIVE_INFINITY
The primitive types are passed to methods by value, but Object types are passed by reference.
Below you will find each of these primitive types with detailed information.
I suggest you studying the following table. You may be asked to answer questions
coming out of the following table.
For instance, a question might be about the size or the range of a primitive type.
Primitive Types and Their Properties |
|||||
Primitive Type | Size (in bits) |
Default Value |
Wrapper class |
Minimum Value | Maximum Value |
boolean |
N/A | false | Boolean | false | true |
byte |
8 | 0 | Byte | -128 -27 ( Byte.MIN_VALUE ) |
127 27-1 ( Byte.MAX_VALUE ) |
short |
16 | 0 | Short | -32,768 -215 ( Short.MIN_VALUE ) |
32,767 215-1 ( Short.MAX_VALUE ) |
char |
16 | ‘u0000’ | Char | 0 ( Character.MIN_VALUE ) |
65,535 216-1 ( Character.MAX_VALUE ) |
int |
32 | 0 | Integer | -2,147,483,648 -231 ( Integer.MIN_VALUE ) |
2,147,483,647 231-1 ( Integer.MAX_VALUE ) |
long |
64 | 0L | Long | -9,223,372,036,854,775,808 -263 ( Long.MIN_VALUE ) |
9,223,372,036,854,775,807 263-1 ( Long.MAX_VALUE ) |
float |
32 | 0.0F | Float |
1.40129846432481707e-45 ( Float.MIN_VALUE ) |
3.40282346638528860e+38 ( Float.MAX_VALUE ) |
double |
64 | 0.0 | Double |
4.94065645841246544e-324 ( Double.MIN_VALUE ) |
1.7976931348623157e+308 ( Double.MAX_VALUE ) |
Literals
A literal is a value, which can be assigned to a primitive type or a String. For
example:
Variable definition | Literal definition | ||
String myVariable | = | “literal”; | // a String literal |
char my_char | = | ‘c’; | // a char literal |
boolean isWriting | = | true; | // a boolean literal |
short my_short | = | 28; | // an Integral literal |
double my_double | = | 3.14; | // a Floating-point literal |
‘null’ and ‘boolean’ literals
The ‘null’ literal can only be assigned to a reference type (Object).
It is not allowed to assign a primitive type to ‘null’. The ‘null’ literal indicates that
the Object reference has no value.
We can only assign boolean literals to boolean primitive types.
There are exactly two boolean literal values: ‘true’ and ‘false’.
Examples are:
Variable definition | Literal definition | ||
String myVariable | = | null; | // a null literal |
char my_char | = | null; | // Illegal! char is not an object // it is a primitive type |
boolean isSchool | = | true; | // a boolean literal |
boolean isBook | = | “true”; | // Illegal! “true” is not a boolean literal // it is an object ( reference type ) |
double my_double | = | 3.14; | // a Floating-point literal |
‘char’ literals
We can define a char literal as a single letter, an escape sequence, a digit,
or a Unicode letter enclosed in single quotes.
We cannot directly use a single quote, or a backslash in single quotes.
We can indirectly use those characters by using character escape sequences.
Examples are:
Variable definition | Literal definition | ||
char my_char | = | ‘c’; | // legal |
char my_unicode_char | = | ‘u0062’; | // legal |
char my_tab_char | = | ‘t’; | // legal |
char my_backslash_char | = | ”; | // legal |
char my_backslash_char1 | = | ”; | // Illegal |
char my_single_queto_char | = | ”’; | // legal |
char my_single_queto_char1 | = | ”’; | // Illegal |
char my_double_queto_char | = | ‘”‘; | // legal |
The following list shows the list of character escape sequences.
Character Escape Sequences | |
b | backspace |
t | tab |
n | linefeed |
f | form feed |
r | carriage return |
“ | double quote |
‘ | single quote |
backslash |
As you can see, those character escape sequences — except double-quote, single-quote,
and the backslash character — don’t have a graphical representation.
String literals
We can define a String literal as a set of char literal. It is simply a set of char
literals enclosed in double-quotes.
It is allowed to define single-quotes, but it is not allowed to define double-quotes
or the backslash character directly.
We can use character escape sequences to define those values indirectly.
Examples are:
Variable definition | Literal definition | ||
String my_String_literal | = | “Basic examples”; | // legal |
String my_Str_literal | = | “u0062asic examples”; | // legal |
String my_Str | = | “t Examples”; | // legal |
String my_Str_with_quetos | = | “”Examples””; | // legal |
String my_Str_with_s_quetos | = | “‘”; | // legal |
String my_Str_with_bs_quetos | = | “”; | // Illegal |
String my_Str_with_d_quetos | = | “””; | // Illegal |
String my_Str_with_d_quetos1 | = | “””; | // legal |
Integral literals
We can define an integral literal as octal, decimal, or hexadecimal integers.
The default is decimal.
An octal litarel value is preceded by 0, and subsequent digits can be any between 0 and 7
(inclusive).
A decimal value must begin with a digit between 1 and 9, subsequent digits can be
between 0 and 9.
A hexadecimal value must have 0x, or 0X prefix subsequent characters can be a
digit or a letter.
The digits are between 0 and 9, and the letters can be a, b, c, d, e, or f (case intensive).
An integral literal is decimal and its type is 32 bit ‘int’ by default. For that reason,
the compiler will throw an exception if we define an integral literal exceeding the
range of ‘int’ primitive type.
The ‘long’ primitive type is defined by an ‘l’ or ‘L’ suffix of the literal. For example,
254L or 254l is a long literal.
Examples are:
Variable definition | Literal definition | ||
int my_literal | = | 512; | // legal |
long my_long_literal | = | 512L; | // legal |
int my_octal_literal | = | 054; | // legal |
int my_hex_literal | = | 0xdF; | // legal |
Floating-point literals
As mentioned before, a floating-point literal complies with the IEEE 754
floating-point specification.
We can define a floating-point literal by adding ‘f’, ‘d’, a decimal point, or an
exponential letter ‘e’ to the
literal value. The letters ‘f’ and ‘d’ specify the type of the literal. That is to say, if
we use ‘f’, the literal
will be identified as a float value by the compiler. For example, 3.14f literal is
type of float. The default value is
double. Namely, if we do not mention a letter (‘d’ or ‘f’) the literal will be
identified as type of double.
It is also possible to specify the ‘double’ type explicitly by adding a ‘d’ or ‘D’ suffix.
We can define float-point literals, which are type of ‘float’, by adding a ‘f’ or ‘F’ suffix.
For example, both 3.14f, and 3.14F are valid floating-point literals.
Floating point literals can also have an exponential part. The exponential part has an ‘
e’ or ‘E’ prefix and optional ‘+’ or ‘-‘ signs followed by digits. For example,
0.23E-2 is a valid floating-point number with exponential part.
The following table shows the four possible floating-point representations.
Example | Rule | ||
1.) | 314. 3.14 3.14f 314.e-2 314.d | one or more digits, and ‘.’ followed by optional part, which can be digits, an exponential part, or a floating-point suffix | |
2.) | .314 .314f .314f .314e-3 .314e-3d | one ‘.’ and one or more digits, followed by optional part, which can be an exponential part, or a floating-point suffix | |
3.) | 314e-2 314e-2f 314e-2d | one or more digits, and one exponential part followed by optional floating-point suffix | |
4.) | 314e-2f 314f 314d 314e2d | one or more digits, and one optional exponential part followed by mandatory floating-point suffix |
Arrays
An array is a storage place of a list of items of the same type.
An array can be either a collection of primitive types or object references.
We cannot define two different type in an array.
Every element of an array must be of the same type.
A Java array is type Object. Therefore, methods of type Object can be called on
an array. The size of an array cannot be changed
once the array is created. The elements of an array can be accessed by
an index value that is greater or equal to zero.
The index value is type ‘int’ and cannot be a negative number.
If the array size is specified by n then the
elements of the array can be accessed by an index value between the range of 0 and n-1.
It is possible to create an array with zero elements. Once an array is declared and allocated,
array elements are automatically initialized to a default value, wherever the array is defined.
It does not matter whether the array is declared at class level (member) or method level (local),
the elements of the array will always be initialized to the default value of the element.
Reference variables are initialized to ‘null’ and primitive types are initialized to the default values.
However, there will not be an automatic initialization if the array is only declared (not allocated).
Arrays should be declared, allocated, and initialized. The following table shows a couple of array examples
that have been declared, allocated, and set to either a specific or a default value.
Declaration | Allocation | Initiliazation | ||
int []a; | a | = | new int[ 5 ]; | // Every element is implicitly // initialized to 0 |
String str[]; | str | = | new String[ 3 ]; | // Every element is implicitly // initialized to null |
double []d; | d | = | new double[ 5 ]; | // Every element is implicitly // initialized to 0.0 |
As you can see, we do not specify the size of the array in the declaration part.
Alternatively, it is possible to declare, allocate, and define a list of custom elements in one step.
That is done as follows.
Example
All in one step | |||
int []a | = | {1,2,3,4,5}; | // legal |
int []a[] | = | {new int[]{2,3,4},{1,2}}; | // legal |
int a[][] | = | {new int[3],{1,2}}; | // legal |
int [5]a | = | {1,2,3,4,5}; | // illegal. definning array size is // never allowed at the first half |
int []a | = | new int[5]{1,2,3,4,5}; | // illegal. Cannot define dimension // expressions when an array // initializer is provided |
Variable Types and Variable Initialization
We can classify variables according to their lifetimes. In this respect, there are two
types of variables : member and method local. Member variables are declared at class level
(like methods).
A member variable is automatically initialized to a default value. The list of default
values is mentioned and a
table is given in the previous section.
A member variable is implicitly initialized to null if declared as an Object reference,
and initialized to a default value if declared as a primitive type.
Method local variables are declared in a method. Method local variables are not
initialized to a default value;
therefore, they must be initialized to a value explicitly.
Member and local variables |
|
Sample Code
You can use the following code to practice on this topic.
Sample Code |
|
Questions
- Which of the followings are valid array declarations? (Select one or more answers)
a.) int k[][] = new int[5,3];
b.) int i[] = new i[];
c.) int int[] = new int[];
d.) int [][]i= new int[3][4];
e.) int []a = {1,2,3,4,5};
- What is the hexadecimal representation of 12 as a valid Java literal?
a.) 12
b.) C
c.) c
d.) 0C
e.) 0xc
- What are the legal identifers in Java? (Select one or more answers)
a.) %factory
b.) $factory
c.) object-factory
d.) for
e.) _byte
f.) 3rdfactory
g.) Int
- What is the output of the following program?
class Example{
static int sequence[] = {1, 2, 3, 4, 5};
public static void main(String args[]){
System.out.println(” The value of sequence[4] is ”
+ sequence[4]);
}
}
a.) Null Pointer exception is raised
b.) Runtime error, because the class is not instantiated
c.) The value of sequence[4] is 0
d.) The value of sequence[4] is 5
e.) The value of sequence[4] is null
- What is the range of an int?
a.) -2-32 , 232
b.) -2-31 , 231
c.) -2-31-1 , 231
d.) -231 , 231-1
e.) -2-31 , 231-1
f.) 0, 232
Answers
I suggest you compile and try other possible combinations by yourself. Practical
work is important for the exam. Instead of just looking at the answers, try to compile
the code and learn from the results you receive.
- d,e
- e
- b,e,g
- d
- d
References
[ 1 ]. Java
Language Specification (Second Edition) by James Gosling, Bill
Joy, Guy Steele
[ 2 ]. Information
about SCJP Certification
[ 3 ]. Sun
Certified Programmer for Java 2 Platform Success Guide
[ 4 ]. SJCP
Exam Preparation: Top-level and Inner Classes
[ 5 ]. http://www.unicode.org
About the Author
Koray Guclu holds a Computer Engineering degree. He works as a software developer and
freelance author. You can reach him at korayguclu@yahoo.com.
His Web site is http://www.geocities.com/korayguclu/.