Haining Mu

Originally posted by Mathias P.W Nilsson:
Great score Haining! I'm up in about 2 weeks. I must say I'm still week on Threads and io. Did you just read Khaild's book and RHE or do you have other suggestions?

Khaild's book should be enough if you do remember everything in there. you may need read carefully and practice on thread cuz most of us don't have much experience programming that. I do have 3~4 questions on sync. 2~3 on contructors and 2~3 on its methods. for IO, normlly remember contructors should be OK, but I do have a question regarding its methods.
beside book and mocks, I do read some chapters of JLS, it will help you to clear the doubt, expecially on override, overload, etc. For some class like "String", "Math", you do need to know what exactly method does by reading through javadoc.
good luck

Originally posted by Ashik uzzaman:

Congrats Haining! Great score!!
How many questions were on I/O and how much time did u take? Did u use JQ+/J@Whiz?

I had at least 5 questions on I/O, 4 of them are test constructors. I spent less than an hour to answer all questions and marked about 5 to review. enough time to check second time.
i didn't use JQ+/J@Whiz cuz they are NOT free.

missed two questions, one in inner class, one in thread.
for those who are giong to take exam, these two topics must be read through. a lot of questions from there. for IO, various constructors are important. I don't have any filling blank question.
I read Mughal, Exam Cram and Roberts, found Mughal is most useful to get high score.
I took every FREE mock exams avaiable through this site.

Originally posted by anand raman:
the answer will not be affected by just changing the data type of the variable a. As i understand it, the return type of ternary operator is determined by the types of the true and false option. The return type will be determined by the larger option.

NOT absolutly right. for this code:
System.out.println("Value is - " + ((3 < 5) ? 9.9 : 9)); will give output "9" instead of 9.0 although double is widen than int here.

Let me try to explain with rules in JLS 15.12 - method invocation. At complie time, we need determine method signature. According to JLS 15.12.2.2-choose the most specific method. Here are the rules:

If more than one method declaration is both accessible and applicable to a method invocation, it is necessary to choose one to provide the descriptor for the run-time method dispatch. The Java programming language uses the rule that the most specific method is chosen.
The informal intuition is that one method declaration is more specific than another if any invocation handled by the first method could be passed on to the other one without a compile-time type error.
The precise definition is as follows. Let m be a name and suppose that there are two declarations of methods named m, each having n parameters. Suppose that one declaration appears within a class or interface T and that the types of the parameters are T1, . . . , Tn; suppose moreover that the other declaration appears within a class or interface U and that the types of the parameters are U1, . . . , Un. Then the method m declared in T is more specific than the method m declared in U if and only if both of the following are true:

T can be converted to U by method invocation conversion.
Tj can be converted to Uj by method invocation conversion, for all j from 1 to n.
So for your question:
case 1:
public class Test { public static void main(String argv[]){ B b1 = new B(); b1.yy(3); } } class A { public void yy (int i) {System.out.println(i);} } class B extends A { public void yy (long i) {System.out.println(i*2);} }
both method yy(int i) and (long i) are accessible and applicable. But here A can NOT convert to B although int i can convert to long i. Similarly, B can convert to A but long i can NOT convert to int i. Therefore, neither method is SPECIFIC to the other, you got ambiguous complie error.
case 2:
if you change b1.yy(3); to b1.yy(3L), only ONE method is applicable, it is yy(long i).
case 3: interesting one if you change B b1 = new B() to A b1 = new B(), ie.
public class Test { public static void main(String argv[]){ A b1 = new B(); b1.yy(3); } } class A { public void yy (int i) {System.out.println(i);} } class B extends A { public void yy (long i) {System.out.println(i*2);} }
you get result 3, because at compile time, type A (variable b1) has only ONE method applicable. If you now change the call to b1.yy(3L), you got compile error for method not found.
case 4: if you switch method in A and B, declare bi A;
public class Test { public static void main(String argv[]){ A b1 = new B(); b1.yy(3); } } class A { public void yy (long i) {System.out.println(i);} } class B extends A { public void yy (int i) {System.out.println(i*2);} }
you got output 3 although int parameter is passed, at compile time, only ONE method is applicable.
case 5: this is the case that one method is more specific than other
public class Test { public static void main(String argv[]){ B b1 = new B(); b1.yy(3); } } class A { public void yy (long i) {System.out.println(i);} } class B extends A { public void yy (int i) {System.out.println(i*2);} }
you got output 6. Because you have two method again applicable and B can convert to A and int i can convert to long i, B's method is more specific than A's. This is the same as you define two methods in same class in the example.
Overloaded method is choosen at compile time, overriden method at runtime, they are different.
hope this helps. please indicate if I am wrong.

[This message has been edited by Haining Mu (edited June 22, 2001).]
[This message has been edited by Haining Mu (edited June 22, 2001).]

the B's constructor you call is B(String s), the compiler will insert a "super();" if the first line is neither this(...) nor super(...). So A() is called.
[This message has been edited by Haining Mu (edited June 22, 2001).]

while not frequently used, we still can find examples of inner interface:
Map.Entry in Map
JComboBox.KeySelectionManager in JComboBox

you can find similar questions about string in
http://www.angelfire.com/or/abhilash/Main.html

Answer is A, D.
There is explaination for D in JLS 8.4, it is allowed but old fashion.

to override a method int[] myMethod() in superclass, which of
the following is(are) legal in subclass (select 2 correct answers):
a)int[] myMethod(){...}
b)int myMethod(){...}
c)int myMethod[](){...}
d)int myMethod()[]{...}
e)[]int myMethod(){...}

hi all,here is the samle code from JLS 8.3.2.3 regarding field initialization, I already comment-off what author marked "error", but it still have problems of "forward reference". I also include error from javac. Can anybody explain? Does the author wrong, or Sun's compiler does not strict follow JLS?
class UseBeforeDeclaration { static { x = 100; // ok - assignment //int y = x + 1; // error - read before declaration int v = x = 3; // ok - x at left hand side of assignment int z = UseBeforeDeclaration.x * 2; // ok - not accessed via simple name Object o = new Object(){ void foo(){x++;} // ok - occurs in a different class {x++;} // ok - occurs in a different class }; } { j = 200; // ok - assignment //j = j + 1; // error - right hand side reads before declaration int k = j = j + 1; int n = j = 300; // ok - j at left hand side of assignment //int h = j++; // error - read before declaration int l = this.j * 3; // ok - not accessed via simple name Object o = new Object(){ void foo(){j++;} // ok - occurs in a different class { j = j + 1;} // ok - occurs in a different class }; } int w = x= 3; // ok - x at left hand side of assignment int p = x; // ok - instance initializers may access static fields static int u = (new Object(){int bar(){return x;}}).bar(); // ok - occurs in a different class static int x; int m = j = 4; // ok - j at left hand side of assignment int o = (new Object(){int bar(){return j;}}).bar(); // ok - occurs in a different class int j; }
errors:
D:\>javac UseBeforeDeclaration.java UseBeforeDeclaration.java:3: illegal forward reference x = 100; // ok - assignment ^ UseBeforeDeclaration.java:5: illegal forward reference int v = x = 3; // ok - x at left hand side of assignment ^ UseBeforeDeclaration.java:14: illegal forward reference j = 200; // ok - assignment ^ UseBeforeDeclaration.java:16: illegal forward reference int k = j = j + 1; ^ UseBeforeDeclaration.java:16: illegal forward reference int k = j = j + 1; ^ UseBeforeDeclaration.java:17: illegal forward reference int n = j = 300; // ok - j at left hand side of assignment ^ UseBeforeDeclaration.java:31: illegal forward reference int m = j = 4; // ok - j at left hand side of assignment ^ 7 errors
you can see the original here:
[url = http://java.sun.com/docs/books/jls/second_edition/html/classes.doc.html#287406
[/url]

[This message has been edited by Haining Mu (edited June 19, 2001).]
[This message has been edited by Haining Mu (edited June 19, 2001).]

Is this correct: wait() is an instance method of Thread class

Originally posted by Thomas Paul:
The JLS explains it here:
http://java.sun.com/docs/books/jls/second_edition/html/typesValues.doc.html#9208
The problem is that you are attempting to store an infinitely long number (1/49) within a fixed length field. This is obviously impossible. Rounding/truncation has to occur on the fraction. So when you multiply (1/49) * 49 you do not get 1.

thanks. i was expecting this happen for (1/49) * 49 not equal 1. but why (1/3.) * 3. equal 1. Just remembering somewhere in the book mention these kind of comparison is NEVER true. Hope we shuold have no quesiton in EXAM like this.
[This message has been edited by Haining Mu (edited June 15, 2001).]

Originally posted by Jyotsna Umesh:
Q. If you compile the following code what will be the result?
public class MyClass {
public static void main(String args[]) {
String str1 = "Test One";
String str2 = new String("Test One");
if ( str1.equals( str2) ) {
System.out.println("Both are equal");
}
boolean b = true;
boolean b1 = false;
if ( b.equals(b1) ) {
System.out.println("true");
}
}
}
[a] Compile time error
[b] Runtime error.
[c] No output
[d] "Both are equal" followed by "true"

Compile error, equals() method can not be used for primitive. though first part will be "equal"

reading JLC and have a doubt:
double d = 1/3.;
System.out.println((d*3 == 1)); //true
double d = 1/49.;
System.out.println((d*49 == 1)); //false
not quite understand, can anybody explain? thanks.