Lih Chang

Thank you all. I got it figured out.

Hi,
I'm new in this field. Is it possible to have both Type (the drop down box) and Name replicated when you click add Author as seen in the example Link? Thanks in advance.
[ August 05, 2003: Message edited by: Lih Wang ]
[ August 05, 2003: Message edited by: Lih Wang ]

Marlene, thank you so much for sharing your thought. I think I need to spend more time reading JLS before posting anymore. Thanks again. Here I wrote three more examples with some explanation just to make sure I understood the concept. I used the word "see" in my comment, not sure it is right though. If I was wrong again or missed any critical concept, please correct me. Thanks in advance.
/* class A { float m(float f) { System.out.println("float"); return f; } } class TestOverload1 extends A { char m(char c) { System.out.println("char"); return c; } public static void main(String[] args) { //this compile cleanly and output "char" //a has a reference type of TestOverload1 //at compile time, it "sees" both m(float) and m(char) //and 'x' can be converted to either float or char, so, both methods are applicable //which one is more specific for the compiler to choose //float -> char (no), A -> TestOverload1 (no) //char -> float (yes), TestOverload1 -> A (yes) //therefore, m(char) is selected for method invocation //this has the same effect as new TestOverload1().m('x'); TestOverload1 a = new TestOverload1(); a.m('x'); } } */ /* class A { byte m(byte b) { System.out.println("byte"); return b; } } class TestOverload1 extends A { char m(char c) { System.out.println("char"); return c; } public static void main(String[] args) { //this will give compiler error //because the reference type of a is A //at compile time, only m(byte) is "seen" by a //and 'x' can not be converted to type byte //if A is changed to TestOverload1, output is "char" A a = new TestOverload1(); a.m('x'); } } */ class A { float m(float f) { System.out.println("float"); return f; } } class TestOverload1 extends A { char m(char c) { System.out.println("char"); return c; } public static void main(String[] args) { //this compile cleanly and ouput "float" //Again, a is type of A //therefore, it "sees" m(float) at compile time //and 'x' can be converted to float A a = new TestOverload1(); a.m('x'); } }
[ April 17, 2003: Message edited by: Lih Wang ]

I have tried several other combinations.
class A { //char m(char c) { System.out.println("char"); return c; } int m(int c) { System.out.println("int"); return c; } //float m(float f) { System.out.println("float 1"); return f; } //long m(long f) { System.out.println("long"); return f; } } class TestOverload1 extends A { //long m(long f) { System.out.println("long"); return f; } float m(float f) { System.out.println("float 2"); return f; } //int m(int c) { System.out.println("int"); return c; } //char m(char c) { System.out.println("char"); return c; } public static void main(String[] args) { new TestOverload1().m(10L); } } /* Base Sub param compile output ---------------------------------------------------- float long 'x' OK long long float 'x' error long int 'x' OK int int long 'x' error int float 'x' error float int 'x' OK int float float 'x' OK float in Sub int long 10 error long int 10 OK int int float 10 error float int 10 OK int int long 10L OK long long int 10L OK long float long 10L OK long float int 10L OK float long float 10L error int float 10L OK float */
Based on what I got, I guess that the compiler will choose the most compatible method and find the method from the bottom up in class hierarchy. Hope someone can shed some light on this.

Too many questions and too much confusion - that's why I'm still learning. Thomas, could you please tell me why? Thanks.

Could this be the reason that static method does not participate polymorphism in the class hierarchy? But, why doesn't the compiler convert 'x' to int if both methods were declared as static?

Originally posted by Marlene Miller:
Just in case anyone has not seen this one:
class A { char m(char c) { System.out.println("char"); return c; } } class B extends A { float m(float f) { System.out.println("float"); return f; } public static void main(String[] args) { [B]new B().[/B]m('x'); } }
[ April 16, 2003: Message edited by: Marlene Miller ]

I added new B() in front of the method call. I'm not sure this was what you meant. What's intresting is that if I changed both methods to static, there is no compiler error and prints out 'char'. Don't know exactly why?

After reading JLS 8.2, I'm still not quite understand what's inheritance supposed to mean, even get more confused. If private fields not inherited from its superclass, why an instance of subclass coctains all the member fields - although they are not all visible in the subclass - that superclass has. Does it mean there are two objects (one for all private member fields, one for the others) created for each subclass object created? Of course, this is not true. Then, how do I perceive this? Hpoe someone can help me understand the concept. Thanks.

Originally posted by Thomas Paul:
We seem to be getting confused with inheriting and extending. When I extend a class, I inherit all the non-private members of the class that I extend.

As I understood it, subcalss inherits everything from its superclass. The access modifier private would not prevent inheritance but would prevent access (overloading/overriding) by a subclass. Am I right?

(c)The garbage collector informs your object when it is about to be garbage collected.

Can someone explain what does (c) exactly mean? Thanks.

class Test { public static void main(String[] args) { for (int i = 0; i < 10; i++) { final int x = i; System.out.println(x); } } } Originally posted by Botella
[ April 10, 2003: Message edited by: Thomas Paul ]

It seems that the compiler knows the class hierarchy. In other words, if you modify the code in m() to throw BException and catch AException, then the code compile fine without errors.

I'm not sure I understood correctly. But, here is a code snippet that accessing protected constructor in the subclass of another package.
package pk1; public class Base { protected Base(){ System.out.println("call protected Base Ctor"); } } package pk2; import pk1.*; class Sub extends Base { Sub () {super();} void method(){System.out.println("SUB");} public static void main(String[] args){ Sub s = new Sub(); s.method(); } }

For what I understood, here is the rule:
there are two ways for static final var:
1. static final int i = 10;
2. static final int i;
static { i = 10;}
for non-static final var:
1. final int j = 10;
2. final int j;
{ j = 10;}
3. initialize in constructor but not for static final var since it needs to be initialized before instance created.

Please take a look at the following codes, hope it will give you some hints.
class Parent{
int i=10;
Parent(){
this.showI();
}
public void showI(){
System.out.println("Parent = " + this.i);
}
}
class Child extends Parent{
int i;
Child(){
}
public void showI(){
//the following will access this Child object (pointed to by this)
System.out.println("Child = " + this.i);
//the following will access Parent object (pointed to by super)
System.out.println("Child = " + super.i);
}
public static void main(String[] args){
//the reason that the Child showI() is called in the Parent's Ctor
//is because showI() is dynamically bound.
//In Java, a static method is early bound, other instance methods are late binding.
//In other words, the object that invokes the method will depend on the real object type at the run time.
Child c = new Child(); //the real type for c at run time is type of Child
Parent d = new Child(); //same as above
Parent e = new Parent(); //will invoke showI() in the Parent
}
}