Where to find ans for mock test by Valentinn Cretazz

[Amit Das]

hi all,

i did the mock test by Valentin Cretazz provided here
but when i click on Submit botton it doesn't give me the answers........

plz help if someone knnows the answers...............

thanx
amit

[Jas Oberai]

Hi Amit,
I went to that link,and I could check my results clicking the submit button.The first line on the exam mentions this:

You must have a Javascript-aware web browser in order to take this mock correctly or you won't be able to check your answers

i'm using latest version of I.E,and the other thing is enable your pop-up blocker.That surely would help.
Thanks

[Jas Oberai]

Sorry..i meant to say disable your popup blocker..lol

[Amit Das]

thanks jas,

but i'm using IE 6.0........and how do i disable pop-up blocker???

[Jas Oberai]

I am also using I.E6.0 on XP,on the toolbar you have this option to disable pop-ups,anyways i'll copy-paste the answers for you.It's a good mock-exam,where from did you get this one,i would be obliged if you can tell me some more like this,i already have almost all the simulator exams,marcus,barry,K&B,John,Sun,JavaRanch,Majji etc.

Question 1:  Correct answer: D E  
Comments: 
Relevant sections of the JLS:
    15.26 Assignment Operators
    14.4 Local Variable Declaration Statements
    15.7 Evaluation Order
 

 
--------------------------------------------------------------------------------
Variable z is not declared, thus, z cannot be resolved on lines 2 and 3. In Java, z cannot be declared that way. In order to get this code to compile, we have to write either:
int z=1,x=z;
or
int z=1;
int x=z;
or
int z=1;
int x=1;
(Thanks to Manish Hatwalne for pointing out mistakes)  
 
--------------------------------------------------------------------------------
 
Question 2: Unanswered!. That's wrong! Correct answer: D  
Comments: 
Relevant sections of the JLS:
    3.10.1 Integer Literals
    5.1.3 Narrowing Primitive Conversions 
    15.19 Shift Operators
 
Relevant classes of the API:
    java.lang.Integer 
 

 
--------------------------------------------------------------------------------
First off, 017 is an octal integer literal having the decimal value 15.
Second, the cast to byte only applies to j and not to j >> 2 as a whole. Thus, j is downcast to byte and then upcast to int again before the shifting. Briefly, the cast has no effect here.
Then, the binary sequence of 15 is 00000000 00000000 00000000 00001111, which, shifted 2 bits to the right, yields 00000000 00000000 00000000 00000011.
Finally, the binary sequence, 11, is printed. Note that the prefixed 0's are dismissed.
(Thanks to Corey McGlone for pointing out mistakes)  
 
--------------------------------------------------------------------------------
 
Question 3: Unanswered!. That's wrong! Correct answer: D  
Comments: 
Relevant classes of the API:
    java.lang.Math
    java.awt.Frame
    java.awt.GridLayout
    java.awt.Button
 
--------------------------------------------------------------------------------
The key here is to know that the Math.round() method returns the closest integer (or long) to the given argument.
The method first adds 0.5 to the argument (6.51+0.5=7.01) and then removes the decimal part and returns the obtained integer (or long) which is 7.
The second tricky thing is to know that GridLayout does not take into account the column argument if the row argument is bigger than 0. In this case, the components will be laid out on two lines and the number of columns will be increased as needed.
Finally, the Buttons' labels range from 1 to 7.  
 
--------------------------------------------------------------------------------
 
Question 4: Unanswered!. That's wrong! Correct answer: A D E  
Comments: 
Relevant classes of the API:
    java.lang.System
    java.lang.Object
 
--------------------------------------------------------------------------------
The garbage collection thread is a deamon thread. The latter die when there are no more users threads running.
The garbage collection cannot be forced.
Please read the Java documentation for the finalize() method (above link).
(Thanks to aymen esawey, Steve Lovelace for pointing out mistakes).  
 
--------------------------------------------------------------------------------
 
Question 5: Unanswered!. That's wrong! Correct answer: E  
Comments: 
Relevant sections of the JLS:
    8.4.6 Inheritance, Overriding, and Hiding
    8.4.4 Method Throws
 
Relevant classes of the API:
    java.io.IOException
 

 
--------------------------------------------------------------------------------
The code does not compile because no IOException is thrown when invoking myref.test().
Note that myref's declared and runtime types are Question05Sub and thus no dynamic lookup will be performed.
However, if you change the declared type to Question05, the code will compile and the correct answer would be A because method test() is overridden in Question05Sub.
See the following thread for a discussion about this question:
Question 5 val's mock by Rowan Chattaway  
 
--------------------------------------------------------------------------------
 
Question 6: Unanswered!. That's wrong! Correct answer: C E  
Comments: 
Relevant sections of the JLS:
    15.21 Equality Operators
    15.26 Assignment Operators
 

 
--------------------------------------------------------------------------------
Do not mix b!=b and b=!b. In the former, we check if b's value is different from b's value (?!) which is clearly false. In the latter, we assign b's opposite value to itself, that is, if b is true, then after b=!b, b ends up being false.
Moreover, be aware that b=i==2 is evaluated as b=(i==2) because operator = has the lowest precedence.
Finally, note that the arguments to the Exception constructor are evaluated from the left to the right. First, b!=b is evaluated, then i=args.length (args.length is 2, so i keeps its value), and finally, b=i==2.
(Thanks to Corey McGlone for pointing out mistakes)  
 
--------------------------------------------------------------------------------
 
Question 7: Unanswered!. That's wrong! Correct answer: A D  
Comments: 
Relevant sections of the JLS:
    8.1.3 Superclasses and Subclasses 
    8.1.4 Superinterfaces
    5.5 Casting Conversion
    5.1.5 Narrowing Reference Conversions
    15.16 Cast Expressions 
 

 
--------------------------------------------------------------------------------
First, pay attention to the class hierarchy (B and C are sibling classes!!) Then, there is no such thing as forward-referencing issues when using interfaces declared later in the compilation unit. On line 4, we are dealing with an object whose runtime type is D which implements interface E. The cast is mandatory, though, since the reference type (A) is not assignment compatible with the reference type E. The cast on line 5 is mandatory for the same reasons.
(Thanks to Rajinder Yadav for pointing out mistakes)  
 
--------------------------------------------------------------------------------
 
Question 8: Unanswered!. That's wrong! Correct answer: D  
Comments: 
Relevant sections of the JLS:
    10 Arrays
    14.13 The for Statement
    15.10 Array Creation Expressions
 

 
--------------------------------------------------------------------------------
We declare an array of Object of length two. We then initialize each element to a new Object. We have 2 objects in the array and the array itself (which is an object, too!), that makes 3.
(Thanks to Rajinder Yadav, Rob Ross, Corey McGlone and Marlene Miller for pointing out mistakes)  
 
--------------------------------------------------------------------------------
 
Question 9: Unanswered!. That's wrong! Correct answer: B  
Comments: 
Relevant sections of the JLS:
    14.19 The try statement
    14.17 The throw Statement
    5.1.3 Narrowing Primitive Conversions
    14.9 The if Statement 
 
Relevant classes of the API:
    java.lang.Math 
    java.lang.Exception 
 

 
--------------------------------------------------------------------------------
The code does not compile because i (declared in the try block!) is not in scope when accessed from the catch block.
(Thanks to Marilyn deQueiroz for pointing out mistakes)  
 
--------------------------------------------------------------------------------
 
Question 10: Unanswered!. That's wrong! Correct answer: B  
Comments: 
Relevant sections of the JLS:
    14.13 The for Statement
    15.9.5 Anonymous Class Declarations 
    8.1.2 Inner Classes and Enclosing Instances
 
Relevant classes of the API:
    java.lang.Thread
    java.lang.Runnable
 

 
--------------------------------------------------------------------------------
The code does not compile because the anonymous inner class (new Runnable(){...}) tries to access the non-final local variable i (see the 3rd JLS link above).  
 
--------------------------------------------------------------------------------
 
Question 11: Unanswered!. That's wrong! Correct answer: D  
Comments: 
Relevant sections of the JLS:
    8.4.1 Formal Parameters 
 
Relevant classes of the API:
    java.lang.StringBuffer
    java.lang.String
 

 
--------------------------------------------------------------------------------
Whenever you perform some operation upon a String object, you will get a new String object if the operation had some effect on the original String, we say that a String is immutable and that its sequence of characters cannot be changed.
Here, we are dealing with a StringBuffer which is an implementation of a mutable String, that is you can modify the character sequence it contains. Whenever you perform an operation upon a StringBuffer, the same StringBuffer (whose content has been modified) is returned.
The next important thing to remember is that when a reference to an object is passed as argument to a method, a copy of the reference is actually passed to the method. In this case, buf1 is passed to addSomeStuff and replace is invoked upon it. The changes operated by replace are affecting buf1. We then store the reference to buf (which references the same object as buf1 into a local StringBuffer called b. With that in mind you can actually figure out what the code outputs.
(Thanks to Corey McGlone for pointing out mistakes)  
 
--------------------------------------------------------------------------------
 
Question 12: Unanswered!. That's wrong! Correct answer: B E  
Comments: 
Relevant sections of the JLS:
    15.18.1 String Concatenation Operator +
    3.10.1 Integer Literals (Hexadecimal values)
 
Relevant classes of the API:
    java.io.RandomAccessFile
    java.lang.Integer
 

 
--------------------------------------------------------------------------------
We write one int (4 bytes) one short (2 bytes) and one byte (1 byte). Then, we read 2 shorts. What you should do in cases like this is write what is actually written in the file. Here goes: First an int 0x00000001 (remember that an int is 32 bits long), then a short 0x0023 and finally a byte 0x45. test.dat now contains 00000001002345. We place the file pointer to the 3rd byte, let's say we remove what comes before the 3rd byte, we end up with 01002345. Now we read 2 shorts, that is, 0100 and 2345.
Remember that all this is in hexadecimal notation and thus 0x45 represents 1 byte (that is 8 bits). Moreover, when using hexadecimal notation, remember that each digit stands for 4 bits, thus 0x45 is actually 0100 0101.  
 
--------------------------------------------------------------------------------
 
Question 13: Unanswered!. That's wrong! Correct answer: C D  
Comments: 
Relevant classes of the API:
    java.util.Vector
    java.lang.Integer
    java.lang.Float
 
--------------------------------------------------------------------------------
This question mainly tests your knowledge of the various wrapper classes' constructors. The most notorious thing here is that we can actually give a double as an argument to the Float constructor.
Otherwise, the question tests your ability to understand how Collection classes work. The effect of add(), elementAt() and setElementAt() is trivial, just have a look at the API of the Vector class for more information.  
 
--------------------------------------------------------------------------------
 
Question 14: Unanswered!. That's wrong! Correct answer: B D  
Comments: 
Relevant classes of the API:
    java.io.FileInputStream 
 
--------------------------------------------------------------------------------
The answers to this question are to be found mainly in the provided API link above.  
 
--------------------------------------------------------------------------------
 
Question 15: Unanswered!. That's wrong! Correct answer: C E  
Comments: 
Relevant sections of the JLS:
    3.10.5 String Literals
    3.10.6 Escape Sequences for Character and String Literals
    3.2 Lexical Translations
    3.3 Unicode Escapes
 

 
--------------------------------------------------------------------------------
This shows you that Unicode characters are processed very early during the lexical parsing of a Java source file. Here LF, which is a line terminator, is actually translated to a line terminator and this results in malformed Java code. For instance, the example given above is actually interpreted as:
String s = "Hello
World";
You can notice that the first line is unterminated and the compiler lets you know that.  
 
--------------------------------------------------------------------------------
 
Question 16: Unanswered!. That's wrong! Correct answer: B C  
Comments: 
Relevant sections of the JLS:
    15.26.2 Compound Assignment Operators 
    15.20.1 Numerical Comparison Operators
 
Relevant classes of the API:
    java.lang.Math#floor
    java.lang.Math#random
    java.lang.ArithmeticException
 

 
--------------------------------------------------------------------------------
An ArithmeticException is always thrown when executing this code because Math.random() returns a double between 0.00000 and 0.999999 and Math.floor() just removes the decimal part (the part after the dot). So, the result of the combination of Math.floor(Math.random()) is always 0.0. The cast to int guarantees that 0 will be returned, and an integer division by 0 does always throw an ArithmeticException.
(Thanks to Corey McGlone for pointing out mistakes).  
 
--------------------------------------------------------------------------------
 
Question 17: Unanswered!. That's wrong! Correct answer: A B  
Comments: 
Relevant sections of the JLS:
    15.9.5 Anonymous Class Declarations 
    8.4.1 Formal Parameters (final)
    14.13 The for Statement
 
Relevant classes of the API:
    java.lang.Thread
    java.lang.Runnable
 

 
--------------------------------------------------------------------------------
We wait on Thread t1 to finish before printing End but none of the threads are started so only End is printed. Moreover, the same output will be printed whichever the platform is.  
 
--------------------------------------------------------------------------------
 
Question 18: Unanswered!. That's wrong! Correct answer: A D  
Comments: 
Relevant sections of the JLS:
    15.20.1 Numerical Comparison Operators
    5.1.3 Narrowing Primitive Conversions
    5.3 Method Invocation Conversion
    14.16 The return Statement
 
Relevant classes of the API:
    java.lang.Math#random
 

 
--------------------------------------------------------------------------------
Line 1 does not compile because getPrimitive() takes a byte and we pass it an int. In a normal assignment (byte b = 127 :wink:  this would work because 127 is in the range for byte values and the compiler implicitely does a norrowing conversion. But this is not the case in method invocations. A quote from JLS 5.3: "The designers of the Java programming language felt that including these implicit narrowing conversions would add additional complexity to the overloaded method matching resolution process". This speaks for itself.
Line 3 compiles fine because we have to do with a widening primitive conversion form short to int which is perfectly straightforward.  
 
--------------------------------------------------------------------------------
 
Question 19: Unanswered!. That's wrong! Correct answer: B C D  
Comments: 
Relevant sections of the JLS:
    8.4.6 Inheritance, Overriding, and Hiding
    8.4.7 Overloading
 

 
--------------------------------------------------------------------------------
The terminology is bad. Overriding is for non-static methods and hiding is for static methods. So the following statements are the only true statements about hiding and overriding:
 
a static method (in a subclass) may hide another static method (in a superclass)
 
a static method (in a subclass) cannot hide a non-static method (in a superclass)
 
a non-static method (in a subclass) may override another non-static method (in a superclass)
 
a non-static method (in a subclass) cannot override a static method (in a superclass)
 
 
--------------------------------------------------------------------------------
 
Question 20: Unanswered!. That's wrong! Correct answer: A C D  
Comments: 
Relevant sections of the JLS:
    8.4.6 Inheritance, Overriding, and Hiding 
    8.4.4 Method Throws 
 

 
--------------------------------------------------------------------------------
myref is an instance of class Question20Sub referenced by a variable of type Question20. Method test() in class Question20 is overridden in class Question20Sub, thus the one to be invoked is the one declared in class Question20Sub (Polymorphism!).
Moreover, test() has no obligation to declare a throws clause (see overriding rules!).
The try-catch block is mandatory because myref could as well reference an instance of class Question20 and in that case the method test() to be invoked would be the one declared in class Question20 which throws an exception.  
 
--------------------------------------------------------------------------------
 
Question 21: Unanswered!. That's wrong! Correct answer: A  
Comments: 
Relevant sections of the JLS:
    15.25 Conditional Operator ? : 
    15.14.1 Postfix Increment Operator ++ 
    15.15.1 Prefix Increment Operator ++ 
    3.2 Lexical Translations
    5.1.3 Narrowing Primitive Conversions 
 
Relevant classes of the API:
    java.lang.Math#random 
 

 
--------------------------------------------------------------------------------
No problem here, the code compiles fine. One thing to be aware of is that i+++ ++i compiles fine because of the way Java code is actually parsed. The parser tokenizes the source in bunches of longest valid character sequences. i+++ ++i will be tokenized as i,++,+,++,i and interpreted as i++ + ++i, that is i post-incremented plus i pre-incremented.
Then you have to know how the ternary conditional ?: operator works, that is, it always evaluates its first operand and then depending on the results, evaluates the second OR the third operand (never both). So getBoolean() returns either true or false, thus the code either prints i=2*i++ or i+++ ++i. The former is equivalent to i=2*i and the latter to 2*i+2.
See the following threads for excellent discussions about post/pre-incrementation issues:
Maha Anna's method
Dissecting the post-fix operator by Brian Lugo  
 
--------------------------------------------------------------------------------
 
Question 22: Unanswered!. That's wrong! Correct answer: C D  
Comments: 
Relevant classes of the API:
    java.awt.Frame 
    java.awt.BorderLayout
    java.awt.Button
    java.awt.Label
 
--------------------------------------------------------------------------------
This question mainly tests your understanding of how BorderLayout works. A container laid out by an instance of BorderLayout cannot contain more than 1 component per region, that is 5 at most in the whole container. Being aware of that, the rest is just a matter of drawing the Frame onto a piece of paper. The API describe extensively how the component adding process is carried out.  
 
--------------------------------------------------------------------------------
 
Question 23: Unanswered!. That's wrong! Correct answer: A E  
Comments: 
Relevant sections of the JLS:
    8.4.6.2 Hiding (by Class Methods)
 

 
--------------------------------------------------------------------------------
The wording of the question is clear, we run Question23 and not Question23Sub. The main() method of Question23 is empty, thus nothing is printed.
Moreover, the main() method is just another static method, and thus, it can be hidden.
(Thanks to Sam England for pointing out mistakes).  
 
--------------------------------------------------------------------------------
 
Question 24: Unanswered!. That's wrong! Correct answer: D E  
Comments: 
Relevant sections of the JLS:
    15.12.4.6 Example: Target Reference and Static Methods
    15.12.4.1 Compute Target Reference (If Necessary) 
 

 
--------------------------------------------------------------------------------
The main thing to remember about static methods is that they are class methods and they don't need any target object reference to be invoked upon. It is perfectly legal (but bad practice) to invoke a static method on a null reference as on lines 1 and 2. Static methods invocations should be prefixed with the name of the class they are declared in. In your case, we should invoke throwDice as follows:
Question24.throwDice();
or jus
throwDice();
but the former solution is preferred since we have a clue of where throwDice() (in which class) can be found, namely in class Question24.  
 
--------------------------------------------------------------------------------
 
Question 25: Unanswered!. That's wrong! Correct answer: C E  
Comments: 
Relevant sections of the JLS:
    8.1.2 Inner Classes and Enclosing Instances 
    8.3.1.1 Static Fields
    8.5.2 Static Member Type Declarations
    15.11.1 Field Access Using a Primary
 

 
--------------------------------------------------------------------------------
This question is about member accessibility. If you remember that a member is accessible within the whole class scope, then you are ok. Although class Question25Inner's member i is declared private, it is still accessible in class Question25 because the latter encloses the former, and thus, has access to everything defined in it.
Then, be aware that member inner is static, and thus, it is the same for both instances of Question25 contained in the q25 array. If q25[0] makes some changes to inner, then those changes will be perceptible for q25[1], too, because they share the same Question25Inner object.  
 
--------------------------------------------------------------------------------
 
Question 26: Unanswered!. That's wrong! Correct answer: D  
Comments: 
Relevant classes of the API:
    java.util.Set
    java.util.HashSet
 
--------------------------------------------------------------------------------
Basically, a Set may contain at most one reference to an object and at most one null literal. This being said, it is just a matter of sketching both sets on a piece of paper and know what the effect of retainAll is, which is to discard all references in s1 that are not contained in s2.  
 
--------------------------------------------------------------------------------
 
Question 27: Unanswered!. That's wrong! Correct answer: B E  
Comments: 
Relevant sections of the JLS:
    15.22.1 Integer Bitwise Operators
    3.10.1 Integer Literals (hexadecimal)
 
Relevant classes of the API:
    java.io.FileOutputStream
    java.io.BufferedOutputStream
    java.io.DataOutputStream
    java.io.FileInputStream
    java.io.BufferedInputStream
    java.io.DataInputStream
 

 
--------------------------------------------------------------------------------
When dealing with such problems, always write down what is actually written onto the stream. In our case, we first write a byte 0xFF (1 byte), then a short 0xFF00 (2 bytes) and finally an int 0x12345678 (4 bytes). The content of test27.dat is the following: FFFF0012345678.
Then we read one short (2 bytes), one byte (1 byte) and finally one int (4 bytes). Thus, i will be 0xFFFF, j will be 0x00 and k 0x12345678. We then perform a bitwise AND with i and j. Both, i and j are promoted to int, so the expression looks like this: 0x0000FFFF & 0x00000000 which yields 0x00000000 or simply 0.  
 
--------------------------------------------------------------------------------
 
Question 28: Unanswered!. That's wrong! Correct answer: C  
Comments: 
Relevant sections of the JLS:
    14.7 Labeled Statements
    14.13 The for Statement
    15.20.1 Numerical Comparison Operators 
    14.14 The break Statement
    14.9 The if Statement
    15.14 Postfix Expressions
 

 
--------------------------------------------------------------------------------
This code seems to be overly complicated, but it's not. We have to figure out what the flow is and in such questions, it is always simple, although it doesn't seem at the first sight.
A good way to handle this is to write the values of variables i,j and k for each line 1, 2 and 3 in a table .
 

 line # i j k j>k/i 
 
 line 1 - 2 - - 
 
 line 2 1 3 - - 
 
 line 3 1 2 0 true 
 
 
 
So at the first iteration, the condition j>k/i yields true, and thus, the outer loop breaks. At that moment, j's final value is 2.
The bottom line is don't panic when you are faced with apparently overly complicated nested loops, just try to figure out a simple way out.
(Thanks to aymen esawey, Eric Low for pointing out mistakes).  
 
--------------------------------------------------------------------------------
 
Question 29: Unanswered!. That's wrong! Correct answer: D E  
Comments: 
Relevant classes of the API:
    java.awt.Container
    java.awt.Frame
    java.awt.BorderLayout
    java.awt.Button
 
--------------------------------------------------------------------------------
First a Frame is a Container and a Container is a Component.
Then, you cannot add a container to itself or any other Frame to any container.
(Thanks to Galina Mikheyev for pointing out mistakes).  
 
--------------------------------------------------------------------------------
 
Question 30: Unanswered!. That's wrong! Correct answer: A  
Comments: 
Relevant sections of the JLS:
    8.4.6.2 Hiding (by Class Methods)
    15.12.4.1 Compute Target Reference (If Necessary)
 

 
--------------------------------------------------------------------------------
This may seem like an easy overriding problem but be aware that method printSomething is static, and thus, the actual method to be invoked is the one in the declared type of q30, that is Question30Super.  
 
--------------------------------------------------------------------------------
 
Question 31: Unanswered!. That's wrong! Correct answer: D E  
Comments: 
Relevant sections of the JLS:
    8.4.3 Method Modifiers
    6.6 Access Control
 

 
--------------------------------------------------------------------------------
It doesn't make sense to declare a static method abstract since static method cannot be overridden. Doing so would result in a compile-time error.
Methods can only be overridden to be given more accessibility, thus a protected method can only be overridden to be protected or public.
Private methods are not inherited and thus cannot be overridden,so declaring a private method abstract will result in a compile-time error.
Synchronization is matter of implementation and it is perfectly legal to override a synchronized method to be unsynchronized or the other way around.
Nothing prevents a static method to be declared native. If you think of it, it is just a class method whose implementation lies somewhere in a native library.  
 
--------------------------------------------------------------------------------
 
Question 32: Unanswered!. That's wrong! Correct answer: C  
Comments: 
Relevant sections of the JLS:
    10 Arrays
    15.21.3 Reference Equality Operators == and !=
    3.10.5 String Literals
 
Relevant classes of the API:
    java.lang.String
 

 
--------------------------------------------------------------------------------
The basic thing to know here is that toString() returns this, so s2 and s3 are the same reference, and thus, the reference comparison yields true.
(Thanks to Marilyn deQueiroz for pointing out mistakes)  
 
--------------------------------------------------------------------------------
 
Question 33: Unanswered!. That's wrong! Correct answer: C D  
Comments: 
Relevant sections of the JLS:
    15.7.4 Argument Lists are Evaluated Left-to-Right 
    15.14.1 Postfix Increment Operator ++
    15.11.1 Field Access Using a Primary 
    8.3.1.1 static Fields
 
Relevant classes of the API:
    java.lang.Thread
    java.lang.Runnable
 

 
--------------------------------------------------------------------------------
Yet another tricky Thread question. It's not that tricky if you look at it carefully. If you know that arguments to methods are passed by value then you got the first answer correct. When increment() is invoked, a copy of the value of k is passed on and any change to that value within the method has no effect on the outside.
Then, you can notice that j is static, so threads t1 and t2 share that member. Ther are going to be 2 invocations of method increment(), and thus, the final value of j is 2.  
 
--------------------------------------------------------------------------------
 
Question 34: Unanswered!. That's wrong! Correct answer: B  
Comments: 
Relevant sections of the JLS:
    3.10.1 Integer Literals (hexadecimal)
    3.10.1 Integer Literals (octal)
    15.19 Shift Operators
    15.22.1 Integer Bitwise Operators 
 

 
--------------------------------------------------------------------------------
Pay attention to what kind of integer literals we have, there are some octal number in the expression. So let's translate 0x181 to binary and 010 and 03 to decimal.
The binary expression (without the prefixed 0's!!) looks like 110000001 >> 8 << 3. Then, remember that the shift operators are left-associative, thus,110000001 >> 8 yields 1. Next, 1 << 3 yields 8.
Finally, don't forget the bitwise exclusive OR performed in the println(). 8 ^ 0 yields 8. In XOR operations, only one bit must be 1 in order for the result to be 1, in both other cases, the result is 0.  
 
--------------------------------------------------------------------------------
 
Question 35: Unanswered!. That's wrong! Correct answer: C  
Comments: 
Relevant sections of the JLS:
    15.17.3 Remainder Operator
    14.13 The for Statement
 
Relevant classes of the API:
    java.awt.Frame
    java.awt.GridLayout
    java.awt.Button
 

 
--------------------------------------------------------------------------------
Remember that GridLayout satifies the row needs before the column needs, thus, if we add more than 3 components then we are sure of having three rows, but not necessarly 3 columns. Moreover, we only create a Button when the index is even (i%2==0), but we strangely give them an "uneven" label.  
 
--------------------------------------------------------------------------------
 
Question 36: Unanswered!. That's wrong! Correct answer: B E  
Comments: 
Relevant sections of the JLS:
    8.1.1.1 abstract Classes
    8.1.3 Superclasses and Subclasses
    5.5 Casting Conversion
    15.16 Cast Expressions 
 
Relevant classes of the API:
    java.lang.ClassCastException
 

 
--------------------------------------------------------------------------------
Line 3 is fine since array f1 contains elements of type G which is a subclass of F. The cast to G[]is needed, though, since the declared type of f1 is F[] and F is a superclass of G.
The cast on line 5 is not needed because any element type F, G or H is assignable to a reference of type F.
No ClassCastException are thrown at runtime because we always perform correct cast:
- on line 2, f2 actually contains references to instances of class H, thus the cast to H[] is legal
- on line 4, h1 actually contains references to instances of class H, thus the cast to H[] is legal
- on line 5, g1 contains references to instances of class H, thus the cast to F[] is legitimate.
(Thanks to Rob Ross, Dmitry Golynkin, Shishio San for pointing out mistakes)  
 
--------------------------------------------------------------------------------
 
Question 37: Unanswered!. That's wrong! Correct answer: B D  
Comments: 
Relevant sections of the JLS:
    6.6 Access Control
    14.3 Local Class Declarations
    8.1.2 Inner Classes and Enclosing Instances
 

 
--------------------------------------------------------------------------------
Basically, what is asked here is to know whether the local inner class GoFetchLocal is allowed to access i declared in Question37Super. The answer is yes. Why? Because GoFetchLocal is enclosed within Question37Sub which extends Question37Super. Thus, the former inherits the protected member i which is now accessible within its entire body. Remember that protected members are accessible by all classes from the same package and from the subclasses in other packages.  
 
--------------------------------------------------------------------------------
 
Question 38: Unanswered!. That's wrong! Correct answer: D  
Comments: 
Relevant sections of the JLS:
    14.20 Unreachable Statements
    14.9 The if Statement
    14.11 The while Statement 
    14.12 The do Statement 
    14.13 The for Statement
 

 
--------------------------------------------------------------------------------
This is an unreachable statements problem. Just know that the only allowed solutions are the second (so that programmers may define flag variables for debugging,...) and the third (because the body of a do-loop is always at least executed once).  
 
--------------------------------------------------------------------------------
 
Question 39: Unanswered!. That's wrong! Correct answer: B  
Comments: 
Relevant sections of the JLS:
    8.8 Constructor Declarations
    15.9.3 Choosing the Constructor and its Arguments
    8.8.5.1 Explicit Constructor Invocations
 

 
--------------------------------------------------------------------------------
When we invoke Question39's constructor, it just relays out invocation to its superclass B. Then, what B(int i) does is to invoke the private constructor B(short j) of the same class. The latter, first, implicitely invokes A() (and thus i is initialized to 0) and then assigns j to i, that is i is now 3.  
 
--------------------------------------------------------------------------------
 
Question 40: Unanswered!. That's wrong! Correct answer: E  
Comments: 
Relevant sections of the JLS:
    8.8 Constructor Declarations
    8.8.5.1 Explicit Constructor Invocations
 

 
--------------------------------------------------------------------------------
Invocations to this and super must always be on the first line within the constructor body.
Line 1 is actually fine, since while parsing the compiler won't know that an invocation to this is following on the next line. So it parses line 1 successfully and then when parsing line 2 it will complain.
Moreover, putting line 2 before line 1 brings another problem since we cannot use i (in the argument to this) before the instance is actually created, which will happen after the invocation to this.
To sum up, in order to get this code to compile, you have to put line 2 before line 1 and remove the i in j+i+" Question40".  
 
--------------------------------------------------------------------------------
 
Question 41: Unanswered!. That's wrong! Correct answer: C  
Comments: 
Relevant sections of the JLS:
    14.13 The for Statement
    14.9 The if Statement
    15.10 Array Creation Expressions
    15.21.3 Reference Equality Operators 
    15.25 Conditional Operator
    15.23 Conditional-And Operator
    15.24 Conditional-Or Operator
    15.22.2 Boolean Logical Operators
 

 
--------------------------------------------------------------------------------
We create an array of 3 Object. Whenever the index is even (i%2==0), we create a new instance of Object, otherwise we assign the previous reference, that is, we have created only 2 objects, not 3. Then, the best way to deal with this kind of situation is to actually draw the objects and the reference to them on a piece of paper. Pay attention to the boolean operators used. when short-circuit operators are utilized, not all operands may actually be evaluated. Also pay attention to the use of ==, = and !=.
(Thanks to Corey McGlone for pointing out mistakes)  
 
--------------------------------------------------------------------------------
 
Question 42: Unanswered!. That's wrong! Correct answer: A  
Comments: 
Relevant sections of the JLS:
    15.9.3 Choosing the Constructor and its Arguments
    15.12 Method Invocation Expressions
 

 
--------------------------------------------------------------------------------
Which constructor is chosen? Simply the most specific one, that is, the one whose parameter list matches the types of the argument list. This lookup is carried out the same way as it is done for methods.  
 
--------------------------------------------------------------------------------
 
Question 43: Unanswered!. That's wrong! Correct answer: C D  
Comments: 
Relevant sections of the JLS:
    8.3.2 Initialization of Fields
    8.3.1.1 Static Fields
    8.5.2 Static Member Type Declarations
 

 
--------------------------------------------------------------------------------
There is no compilation error due to forward-reference problems. i and k are static members which are initialized at class-loading time. When an object is created, k is already initialized and its value can be used to initialize the instance member i.  
 
--------------------------------------------------------------------------------
 
Question 44: Unanswered!. That's wrong! Correct answer: E  
Comments: 
Relevant sections of the JLS:
    10 Arrays
    15.10 Array Creation Expressions
    5.1.4 Widening Reference Conversions 
    5.3 Method Invocation Conversion
 

 
--------------------------------------------------------------------------------
Arrays are objects in Java. That means that we can reference casting and conversion applies to them. However, an array containing primitive types (int[], long[],...) will not benefit from widening conversion as conventional objects arrays do. It is not allowed to cast int[] to long[] although there would be no precision loss.
(Thanks to Corey McGlone for pointing out mistakes)  
 
--------------------------------------------------------------------------------
 
Question 45: Unanswered!. That's wrong! Correct answer: B D  
Comments: 
Relevant sections of the JLS:
    8.1.1.1 abstract Classes
 

 
--------------------------------------------------------------------------------
code>Question45 is abstract but we don't care since we don't actually try to instantiate it. We just use its static bMethod() to print something and it works fine. This means that you can invoke any concrete static methods of an abstract class without any problems.  
 
--------------------------------------------------------------------------------
 
Question 46: Unanswered!. That's wrong! Correct answer: C  
Comments: 
Relevant sections of the JLS:
    14.19 The try statement
    15.17.2 Division Operator
    5.1.3 Narrowing Primitive Conversions
 
Relevant classes of the API:
    java.lang.Math#random
    java.lang.ArithmeticException
 

 
--------------------------------------------------------------------------------
The thing here is that an ArithmeticException will always be thrown from within the tryblock. The first catch block catches it and throws a new Exception. Just before throwing the exception and terminate the application, the finally block is executed (as always if present). By executing a return, the finally block discards the exception that was to be thrown and the code returns normally without even printing a tiny bit of the stack trace. Remember that the finally block always has the last word. you can put logic in there that actually decides whether it is worth throwing the exception or simply discarding it.  
 
--------------------------------------------------------------------------------
 
Question 47: Unanswered!. That's wrong! Correct answer: B  
Comments: 
Relevant sections of the JLS:
    3.2 Lexical Translations
    15.14.1 Postfix Increment Operator
    8.4.3.6 synchronized Methods
    17.13 Locks and Synchronization
 
Relevant classes of the API:
    java.lang.Thread
    java.lang.Runnable
 

 
--------------------------------------------------------------------------------
The key here is the invocation t1.join() which has the effect of waiting for thread t1 to die before going on and start thread t2. Thread t1 executes and prints 0 1 2, then dies, and finally, thread t2 runs and prints 0 1 2 again. Be aware that we create both threads with 2 different instances of Question47, thus a being an instance member it will be different for both threads t1 and t2.  
 
--------------------------------------------------------------------------------
 
Question 48: Unanswered!. That's wrong! Correct answer: D  
Comments: 
Relevant sections of the JLS:
    15.17 Multiplicative Operators
    15.18.2 Additive Operators for Numeric Types
    15.19 Shift Operators
    15.22.1 Integer Bitwise Operators
    15.7 Evaluation Order 
 

 
--------------------------------------------------------------------------------
A nice one on operator precedence. The trick is to put paranthesis around operation of bigger priority. After doing that, the expression becomes ((((4*6)-(3/2))<<(2*5))>>>((1%2)-4))^3 and you can do the math easily.  
 
--------------------------------------------------------------------------------
 
Question 49: Unanswered!. That's wrong! Correct answer: B  
Comments: 
Relevant sections of the JLS:
    15.25 Conditional Operator
    15.21.2 Boolean Equality Operators
 

 
--------------------------------------------------------------------------------
Don't mix b=!b and b!=b. The former assigns to b the opposite of its value whiel the latter tests if b's value is different from b's value which always yields false.
We are dealing with the first one here, that means that the value of b will switch from false to true or from true to false.
Then, you have to understand how the ternary conditional operator ?: actually works. This operator has three operands as in op1?op2 :-o	 p3. If op1 is true, then op2 is evaluated, otherwise op3 is evaluated. This can be seen as a short form for if-then-else statements.
The operands are grouped from the right to the left, thus, the expression can be rewritten as (b=!b)?((b=!b)?"Hello":"hello") :(  (b=!b)?"world":"World"). b is initially false. When evaluating the first b=!b, b will be assigned true and the second operand (that is (b=!b)?"Hello":"hello") will be evaluated. b is now true and is assigned its opposite value (false). The second operand ("hello") is thus evaluated.  
 
--------------------------------------------------------------------------------
 
Question 50: Unanswered!. That's wrong! Correct answer: B E  
Comments: 
Relevant sections of the JLS:
    8.4.6 Inheritance, Overriding, and Hiding
    8.4 Method Declarations
 

 
--------------------------------------------------------------------------------
An overriding method must have the same signature (same name, same parameter list, same return type) as the overridden method. Moreover, it cannot throw "more" exceptions than the overridden does, that is, it can only throw:
- the same exception type;
- a subclass of the exception thrown by the overridden method;
- unchecked exceptions (subclasses of RuntimeException);
- not exception at all.  
 
--------------------------------------------------------------------------------
 
Question 51: Unanswered!. That's wrong! Correct answer: E  
Comments: 
Relevant sections of the JLS:
    14.10 The switch Statement 
    5.1.3 Narrowing Primitive Conversions
 
Relevant classes of the API:
    java.lang.Math#random
 

 
--------------------------------------------------------------------------------
The code will not compile since the switch expression must be of type int, short, char or byte. long is not allowed and results in a compile-time error.  
 
--------------------------------------------------------------------------------
 
Question 52: Unanswered!. That's wrong! Correct answer: B D  
Comments: 
Relevant sections of the JLS:
    8.4.3.6 synchronized Methods
    14.18 The synchronized Statement
    15.14 Postfix Expressions
    8.3.1.1 static Fields
 
Relevant classes of the API:
    java.lang.Thread
    java.lang.Runnable
 

 
--------------------------------------------------------------------------------
We create two threads t1 and t2. Each of them has its own Question52 instance which means that there will be two separate members a of class A but the class member i will be the same since it is static. aMethod and bMethod are always invoked one after another. The former always increments i while the latter always decrements i. Declaring the method synchronized or enclosing its body within a synchronized block has the same effect here. The thing is that i's final value will not always be 0. Imagine the following scenario: t1 starts, it invokes aMethod. i is now 1. t1 releases the lock associated with a and the scheduler decides that it is the turn of t2 to run. t2 invokes aMethod and i's value is now 2. You can iterate 10,000,000 times and imagine what may actually happen. The output cannot be predicted in this case.  
 
--------------------------------------------------------------------------------
 
Question 53: Unanswered!. That's wrong! Correct answer: D  
Comments: 
Relevant sections of the JLS:
    8.3.1.1 static Fields
    15.20.2 Type Comparison Operator instanceof
    15.23 Conditional-And Operator
    15.24 Conditional-Or Operator
    15.22.2 Boolean Logical Operators
    15.7 Evaluation Order
 

 
--------------------------------------------------------------------------------
A good tip is to remember that x instanceof y always yields true if the class (or interface) y can be found in the class hierarchy of x, that is:
- y is a superclass of x or x itself
- y is an interface implemented by any superclass of x or by x itself.
There are other rules but they are irrelevant here. Also pay attention to the boolean operator used. Some of them may not actually evaluate all their operands. From there on, you can figure out the answer quite easily. Make sure you consider the runtime type of a1, a2 and a3 and not their declared type, though.  
 
--------------------------------------------------------------------------------
 
Question 54: Unanswered!. That's wrong! Correct answer: B E  
Comments: 
Relevant sections of the JLS:
    8.6 Instance Initializers
    8.7 Static Initializers
    8.3.2 Initialization of Fields
 

 
--------------------------------------------------------------------------------
Distinguish between static members and instance members. The former are initialized at class-loading time while the latter are initialized at instance creation time. First, i is initialized to the default value 0. Then, the static initializer is executed. (0) is printed, then i is assigned the value 3 and (3) is printed. The main method is invoked by the interpreter and (3) is printed. Up till now we have (0)(3)(3). If you made it that far you already have the answer. Then we create an instance of Question54. The instance initializer is executed before the body of the constructor. j is assigned the default value 0. Then, (3,0) is printed, j is assigned 2 and (3,2) is printed. Finally, the body of the constructor executes and prints (3,2) again.  
 
--------------------------------------------------------------------------------
 
Question 55: Unanswered!. That's wrong! Correct answer: E  
Comments: 
Relevant sections of the JLS:
    8.7 Static Initializers
    15.14.1 Postfix Increment Operator
    15.26.1 Simple Assignment Operator
    15.9.5 Anonymous Class Declarations
 
Relevant classes of the API:
    java.lang.Thread
    java.lang.Runnable
 

 
--------------------------------------------------------------------------------
The code does not compile simply because inner classes are not allowed to declare static members variables. They may, however, declare compile-time constant fields (final static or static final).  
 
--------------------------------------------------------------------------------
 
Question 56: Unanswered!. That's wrong! Correct answer: A E  
Comments: 
Relevant sections of the JLS:
    14.11 The while Statement
    14.10 The switch Statement
    14.14 The break Statement
    15.14.1 Postfix Increment Operator
    15.17.3 Remainder Operator
    15.20.1 Numerical Comparison Operators
 

 
--------------------------------------------------------------------------------
The while loop will iterate 5 times (from i=0 to i=4). Then, the expression i%2 may only yield two different values 0 or 1. If the value is 0 (i is even) the default branch is taken otherwise the case 1 branch will be executed. The condition i=0 yields true and then i is incremented (!) to 1. Thus, the first executed branch will be the case and 1 is printed. Then, it will be default's turn and so on.  
 
--------------------------------------------------------------------------------
 
Question 57: Unanswered!. That's wrong! Correct answer: B D  
Comments: 
Relevant sections of the JLS:
    14.13 The for Statement
    15.14 Postfix Expressions
    15.15.2 Prefix Decrement Operator
    15.22.1 Integer Bitwise Operators
    15.15.4 Unary Minus Operator
    15.26 Assignment Operators
    3.10.1 Integer Literals (octal)
    15.20.1 Numerical Comparison Operators
    15.21.1 Numerical Equality Operators
 

 
--------------------------------------------------------------------------------
 

 
for(int i=10;i>0;i-=-2);: i is initialized to 10 and then we substract -2 (that is we add 2) to i at each iteration. The loop ends because i's value keeps increasing until it reaches Integer.MAX_VALUE and wraps around to Integer.MIN_VALUE which is smaller than 0.
 
for(int i=0;i<012;i=i++);: 012 is an octal integer literal whose decimal value is 10. But the trick is in the iteration expression where i is always assigned the value 0. How does that i=i++ work? When executing i++, i's value (0) is stored and then incremented to 1. The value used in the assignment expression is the stored value (0). i will always be 0 and it will never be bigger than 10.
 
for(int i=0;i<0;i--);: clearly the loop breaks at the first iteration.
 
for(int i=0;(i++^--i)==0;i++);: the condition expression i++^--i will always yield 0. We have seen that in i++ we use the actual value of i and then we increment it. In --i, we first decrement i and then we use the decremented value. Thus, i++^--i can be rewritten as i^i and this always yields 0. The condition will never be false and the loop never ends.
 
for(int i=010;i==10;i+=0);: again, 010 is an octal integer literal whose decimal value is 8. Since 8==10 yields false, the loop will never be executed, not even once.
 
Tricky business  :) 
(Thanks to Dirk Sturzebecher, Chulachit Chulamaneechote for pointing out mistakes)  
 
--------------------------------------------------------------------------------
 
Question 58: Unanswered!. That's wrong! Correct answer: A D  
Comments: 
Relevant sections of the JLS:
    8.4.7 Overloading
    8.4 Method Declarations
 

 
--------------------------------------------------------------------------------
The requirements for method overloading are that the method must only have the same name. Everything else in the method signature must be different. There are no requirements on the throws clause or return type either.  
 
--------------------------------------------------------------------------------
 
Question 59: Unanswered!. That's wrong! Correct answer: B E  
Comments: 
Relevant sections of the JLS:
    6.2 Names and Identifiers
    3.8 Identifiers
    3.9 Keywords
    3.10.3 Boolean Literals
    3.10.7 The Null Literal
 

 
--------------------------------------------------------------------------------
This tests your understanding of identifiers. Actually the code compiles and runs fine. Remember that everything in this code is legal (yet not advised!). A class name (String, Question59) can be used as a variable name. A method name (main) can be used as variable name. A class name (Object) can also be used as label name. The compiler is able to handle such bad practices because it knows exactly where to expect what. For instance, when declaring the String variable, it knows that after the type (String), it expects to see an identifier and String (the second one) is accepted. The only requirement for identifiers is to begin with a letter (a to z, A to Z), an underscore ( _ ) or a dollar sign ($) and then followed by any letters or digits. Moreover, the boolean literals true and false, the null literal as well as all keywords cannot be used for that purpose.  
 

[Amit Das]

thanks buddy u made my job easy..... cheers!!!

well there are many but this was(i dont know whether still or not) supposed to be one of toughest mock's in 90's (ofcouse late 90's) till 2003 as i've read.

there are many but i think no use of doing all of 'em so considered-best should be done, yah much depends on your prep. also.....
let me see how much i scored....

thanx
amit