(1) and (3) are integer literals (32 bits), and integers can be legally assigned to

 floats (also 32 bits). (6) is correct because (F) is appended to the literal, 

declaring it as a float rather than a double (the default for floating point literals).

(2), (4),and (5) are all doubles.

Option A is correct. A public access modifier is acceptable. The method prototypes in 

an interface are all abstract by virtue of their declaration, and should not be declared 

abstract.

Option B is wrong. The final modifier means that this method cannot be constructed in 

a subclass. A finalmethod cannot be abstract.

Option C is wrong. static is concerned with the class and not an instance.

Option D is wrong. protected is not permitted when declaring a method of an interface. 

See information below.

Member declarations in an interface disallow the use of some declaration modifiers; 

cannot use transient, volatile, or synchronized in a member declaration in an inter 

you ace. Also, you may not use the private and protected specifiers when declaring 

members of an interface.

(1), (3), and (6) are correct. char c1 = 064770; is an octal representation of the 

integer value 27128, which is legal because it fits into an unsigned 16-bit integer. 

char c3 = 0xbeef; is a hexadecimal representation of the integer value 48879, 

which fits into an unsigned 16-bit integer. char c6 = 'uface'; is a Unicode 

representation of a character.

char c2 = 'face'; is wrong because you can't put more than one character in a 

char literal. The only other acceptable char literal that can go between single quotes

 is a Unicode value, and Unicode literals must always start with a 'u'.

char c4 = u0022; is wrong because the single quotes are missing.

char c5 = 'iface'; is wrong because it appears to be a Unicode representation 

(notice the backslash), but starts with 'i' rather than 'u'.

A boolean can only be assigned the literal true or false.

Option B is the legal way to declare and initialize an array with five elements.

Option A is wrong because it shows an example of instantiating a class

 named Array, passing the integer value 5 to the object's constructor. 

If you don't see the brackets, you can be certain there is no actual array 

object! In other words, an Array object (instance of class Array) is not the

 same as an array object.

Option C is wrong because it shows a legal array declaration, but with no 

initialization.

Option D is wrong (and will not compile) because it declares an array with a 

size. Arrays must never be given a size when declared.

All the words in option B are among the 49 Java keywords. Although goto reserved as a 

keyword in Java, goto is not used and has no function.

Option A is wrong because the keyword for the primitive int starts with a lowercase i.

Option C is wrong because "virtual" is a keyword in C++, but not Java.

Option D is wrong because "constant" is not a keyword. Constants in Java are marked static and final.

Option E is wrong because "include" is a keyword in C, but not in Java.

(1), (2) and (3) are correct. Interfaces can have constants, which are always implicitly public, 

static, and final. Interface constant declarations of public, static, and final are optional in any combination.

(1), (2), and (4) are legal array declarations. With an array declaration, you can place the 

brackets to the right or left of the identifier. Option A looks strange, but it's perfectly legal 

to split the brackets in a multidimensional array, and place them on both sides of the identifier. 

Although coding this way would only annoy your fellow programmers, for the exam, you need 

to know it's legal.

(3) and (5) are wrong because you can't declare an array with a size. The size is only needed 

when the array is actually instantiated (and the JVM needs to know how much space to allocate 

for the array, based on the type of array and the size).

The word "native" is a valid keyword, used to modify a method declaration.

Option A, D and E are not keywords. Option C is wrong because the keyword for subclassing 

in Java is extends, not 'subclasses'.

interface is a valid keyword.

Option B is wrong because although "String" is a class type in Java, "string" is not a keyword.

Option C is wrong because "Float" is a class type. The keyword for the Java primitive is float.

Option D is wrong because "unsigned" is a keyword in C/C++ but not in Java.