leena rane

Congrats Gagan,
What man!! didn't get 101% ....
didn't use all those exam tips i sent to you ??
Oh ,good you have thanked me!!
after all nobody has disturbed you as much as me
cyaa in mailbox,
best regards,
leena

Hearty congratulations Jim!!
very happy for you
Nice day indeed,
i read today that you have become SCJP and my best friend Gagan Indus has become SCWCD almost at the same time
Congratulations again,
and all the best for your future
best regards,
leena.

Originally posted by Marilyn deQueiroz:
Congratulations. You have learned a lot.

Thanx a lot Marilyn.
getting this comment from a sheriff - biggest gift for me from
javaranch.Your comment has indeed encouraged me a lot.
Thanx again,
regards,
leena

Malar,
I am happy to know that my notes helped you.
As i am giving another exam soon,i have a little problem with
time.But i would like to put some notes on thread and i/o as
soon as it is possible and i would be very happy if i can help
anybody preparing for SCJP.In the mean time i hope you have gone
through some tips on i/o preparation that i have given on page 1.
All the best for your preparation
Chandrashekhar,
I will hopefully improve my writing skills soon
1 thing for sure,i like writing a lot.
All the best for SCJP
Shailesh,
thanx a lot for the wishes,
nice to hear from you after so long
all the best for your future
Donald,
thanx for the wishes,
you deserve a pat on your back (AS400 to java)
regards,
leena.

[This message has been edited by leena rane (edited November 15, 2001).]

Jim ,
I can understand you.
It is difficult to be satisfied with preparations to any extent.
Do you know i was actually going to pospone my test(i was not 100% satisfied with my preparation),but in the end could not.
>Prob is I'm getting seriously burnt out! its been 4 1/2 months hard
>work and my concentration is starting to suffer!
dear,i had similar problem in one of the weeks.
So just think,this is natural and forget it and concentrate on your preparation.
>With those scores in mind are they good enough to get a pass
You are really doing good.Keep it up.All the best.
I would suggest:
=>henceforth give topic-wise exam in jwhiz (don't try any other mocks now).
=>before giving exam in a particular topic read books on that topic,
only then give the exam.Make this a rule for every topic.
=>any doubt mark the question,get doubts clarified ...
=>in fact keep notepad and dos-prompt(or whatever u use) open for any clarification,
sometimes i used to get my doubts cleared during the mock-exam through notepad -dos prompt(off course after i became confident of completing exam in time)
=>even if you have got some question in jwhiz rote ..no problem..keep giving the exams.
=>Try to get all answers in JWhiz right!!
(off course it won't be the case when you give 1st time, but gradually..)
"which question in JWhiz dares to come wrong when you are giving it".
Keep repeating this to yourself as you give the exams.concentrate hard on each question.
oops did i talk too much
finally
{
my best wishes are with you
}
best regards,
leena

Great.... man!!!
fond of 90's always ??
keep it up,
cheers!!
how about a treat for the double 90's
(Hey this is my first message at this forum)

Originally posted by chandrashekar munukutla:
Now it is easy to remember.

Happy to know it helped you

In your notes on Object reference and casting above, you mixed
up primitive conversion & casting with Object conversion and
casting.

No i don't think i have mixed up primitive and object conversion
and casting.Every use of an example is intentional,to
simplify some point.I don't know whether you would agree with
this.(off course if anybody feels,it is breaking the link in
reading,please tell me,i shall delete them)

I guess you can give example of Object conversions and casting
as given in RHE. And a note on primitive ones aswell. That
would be great.

RHE is more than sufficient for primitive conversions and
casting.If you are finding any trouble ,do let me know.
regards,
leena.

Congrats Shyam,

I know you deserve much much more than this.
I have seen your preparations,and i don't want to know your marks.I am very happy with a person who has made his java fundamentals strong(though got a little less),
rather than a person who was just exam oriented(and maybe scored high)
So cheer up!!!
(Just say to yourself -> you are certified,and you deserve it)
There is a lot to prove ahead,
All the best for your future
regards,
leena.

ChandraShekhar,
I am extremely sorry,i could not reply your mails.
Let me answer one of your question:
You said you had difficulty remembering operator
precedence,right!!
Let's look at this story from my latest novel
There was a boy named Annar
There was a girl named Arithma shift
both developed a relationship
Finally they got married and bought a house.
One day,there was fire in the house.
The reason of the fire was unclear.
Was that due to bit of short circuit in the house?
Alas,all became = to ash.
Everything was over

The story(the biggest flop) in short:
(now remember only this - forget the bigger story)
<font size=2> [B]Annar[/B] <----> [B]Arithma shift[/B] [B]relationship[/B] [B]bit[/B] of [B]short circuit?[/B] (here you are wondering the reason 4 fire,so read it as a qn) all [B]=[/B] ash
Now let's see the casting for the roles:
<font size=2> Annar : unary operators Arithma : arithmetic operators Shift : shift operators relationship :relational operators(also called Comparison operators) bit :bitwise operators short circuit:short-circuit operators ? :conditional operator(?: ) = :assignment operators(= or "op=")
I hope this will help you,
regards,
leena.

[This message has been edited by leena rane (edited November 08, 2001).]

Originally posted by Jim Petersen:
Leena you should save this for a Book !
Seriously

Jim,
I had a good laugh reading your comment
Thanx a lot.

We come to the end of torture
summary:
1.object reference conversions:
done completely at compile time
none of the 9 rules should be violated,then it compiles.
(while applying rules just look at LHS and RHS types not the
actual object type-which could be totally different than the LHS
and RHS type)
If it compiles then it is definitely going to run//u know why-
done entirely at compile time
2.object reference casting:
a.compile time check->10 rules satisfied then compilation
successful else compile time error
(while applying rules just look at LHS and RHS types not the
object type-which could be totally of different than the LHS and
RHS type)
if it compiles->
b.run-time check:
do what i have said between ****
i.e we actually have to bother what type is the object of
irresective of what type is on RHS.Replace(imagine) RHS type
with some reference of the type,of which the object is actually
of.
Do not change LHS type.
Now ask this question to yourself->can the LHS type point to the
imaginary RHS type
to get the answer to this apply conversions rule

Now we come to object reference casting
<font size=2> Many(not all) conversions which are not possible,are possible due to casting.It is like telling the compiler,please allow me to do this [img]http://www.javaranch.com/ubb/smile.gif[/img] As we have said whether a conversion was valid or not, this decision is taken at compile time itself. But in casting,there are two checks (each has different set of rules), 1.at compile-time 2.at run-time //fortunately run-time rules are similar(not same) to conversion rules so there are 3 kinds of castings now: some which may not even compile some may compile but not be valid at run-time some who compile and are also valid at run time. [B]compile time rules:[/B] here again to check whether a particular casting is valid at run time or not,you just have to concentrate on that particular statement,without seeing the history of previous assignments. (Remember the terms we were using some time back, an old paper which is pointing to the object, now a new paper wants to point to the object, so it wants to copy this address from old paper) Now,replace the word [B]paper[/B] with [B]type[/B] [B]new_type=(new_type)old_type;[/B](got this stmt. then proceed) now we have to check is it valid?? e.g. Button b=new Button("Click"); Object o=(Object)b; //here o is the new type(new paper) which wants to copy address from the old type(old paper) now let us see the [B]compile-time rules:[/B] (if any of them are not satisfied -> compile time error) [B]new_type=(new_type)old_type;[/B] (irrespective of what kind of object it is,these rules only pay attention on the types of new_type and old_type) 1.If both(old_type and new_type) are final classes then both must be the same class 2.If both are non-final classes then any [B]one[/B] of them should extend the other. 3.If any one of them is a final class and the other is a non-final class then: (please use common sense to remember this point-do not memorize) the class which is final should extend the class which is non-final(naturally the final class cannot be extended) 4.If both are interfaces then it is always valid(so nice - no other checks at compile time) 5.If one of them is an interface and other a non-final class it is always valid(again so nice like 4-wish all rules were like this [img]http://www.javaranch.com/ubb/smile.gif[/img]) 6.If one of them is an interface and other is a final class (now this rule is an irritating one) then if new_type is an interface =>old_type should implement the new_type but if old_type is an interface =>new_type should implement the old_type or Serializable (just to remember-the first rule is same as conversion-just add Serializable in the other) 7.If one(any of the two) of the types is an array and other is an interface then [B]compile time error[/B]( [img]http://www.javaranch.com/ubb/smile.gif[/img] good - we don't have to check anything) 8.If one(any of the two) of the types is an array and other is a final class then [B]compile time error[/B](Very good - like 7) 9.If one(any of them) of the types is an array and other is a non-final class then the non-final class [B]must[/B] be of type Object. 10.If both are arrays e.g. Component[] c; Button[] b=new Button[100]; c=(Component)b;//1 b=(Button)c;//2 ------------------------------------ let's check whether 1 and 2 are valid For the moment forget they are arrays i.e. imagine the same example as Component c; Button b=new Button(); c=(Component)b;//3 b=(Button)c;//4 is 3 and 4 valid? apply one of the 9 rules above to decide. Since Component is the superclass of Button so 3 and 4 are both valid [B]by rule 2[/B] 1 will be valid if 3 is valid 2 will be valid if 4 will be valid So we come to the conclusion that both 1 and 2 are valid ------------------------------------------ Now there are two possibilities the casting does not satisfy the 10 rules->compile time error or it satisfies one of the 10 rules->compilation successful (note even if compilation is successful,the casting may or may not be valid at run-time.) ----------------------------------------- [B]run-time rules:[/B] the conversion must actually be valid. e.g. [B]compile time check:[/B] Component c; Button b=new Button(); c=(Component)b;//1 b=(Button)c;//2 note 1 and 2 are valid at compile time due to rule 2. (also note,had casting not been used,2 would not have compiled because we have a subclass on left of =) (draw the diagram for this) c \ \ \ b-------(0) [B]run time check[/B] now here we have to find out what type is the object of? (thousands of diff. types of reference types could point to the same object but the object is of only 1 class) we observe it is of type Button so 1 is actually making a ref. of type Component to point to an object of type Button ,is it valid?Yes in 2 note a Button type is not trying to point a Component type, in run time check, we have to see what is the actual object which is pointed by the type on right of "="(here c).It is actually a Button(draw it on paper and see) so 2 is actually making a Button type to point a Button type,which is valid. so to generalize in run time check-> (forget what type is on right of = ) (in fact since the object is of type Button so imagine on right a reference of Button say b1) so in run time rules you actually *************************** 1.keep LHS as it is 2.on RHS imagine a reference of type of which the object is. so imagine both 1 and 2 as c=b1;//aaa b=b1;///bbb **************************** Now after this apply [B]same[/B] rules as for conversions. (that's why you need 2 know those rules even for casting) we check the rules that we applied for conversions in aaa a Component type will point a Button type -(case A case 1) valid in bbb a Button type will point a Button type - valid

(please do not read completely in 1 day)
<font size=2> [B]object reference conversions[/B]: (i will not be using technical terms, but simple english so that it is made simple) [B]1.what is a reference?[/B] when we say Button b=new Button("Click me"); now you could imagine a Button [B]object created in memory[/B] and now b points(references) it So when we say "label of b" we actually mean the label of the object in memory. So you could imagine the [B]object[/B] as a store-house where everything is stored,and [B]b[/B] as just a piece of paper which has the address for that store-house.Also imagine, an imaginary line between that paper and the store house, as follows(assume (0) is the object in memory): b----------------(0) [B]2.What is reference assignment?[/B] you must be knowing what happens when we say int i=8; int j=i; Here value of i(i.e. 8) is copied in j so that j has the same value now. Similarly,when we say Button b=new Button("Click me"); Object o=b; address in b is copied in o, so now imagine both as piece of paper with the same address. imagine it thus: //consider (0) as the object- but when you draw it on paper //draw it as circle 1. b------------(0) (b points to the object) 2. o \ \ \ \ b------------(0) (the address in b is copied in o-so that both now point to the same object) Now the question remains can we copy this addess to any paper? (i.e b to any thing else) [B]Answer is NO!![/B] The answer to this, answers our question - [B]which conversions are valid after all?[/B] The [B]compiler[/B] is like a watchman,who decides whether to allow the conversion or not. ([B]so note object reference conversions take place at compile time[/B]) So let's look at the answer for this [img]http://www.javaranch.com/ubb/smile.gif[/img] a,b,c,d, are pointing to the object b c \ / \ / \ / \ / a---------(0)---------d Now if you want a variable z to point to the object, you could copy the address from a or b or c or d [B]if it is legel.[/B] Now it is [B]important[/B] to know that just because it is legel to copy from (say) a,we cannot conclude that it may be legel to copy from b,c or d if they are of different type. i.e z=a; is valid does not necessarily imply z=b; z=c; or z=d;are also valid (to know whether they are valid or not, we have set of rules-which we will shortly) Now we will see at an example (though not that good ,will make the point simple) int i=7;//1 double d=i; //2 int i2=d;//3 invalid int i3=i;//4 valid is 3 valid?? NO!! though 4 is valid So though the same value is being copied in all.It actually depends on what is the type of the two on either side of "=" An important point is that to decide whether a conversion is valid or not we have to look at only that statement(the types of RHS and LHS of =) and not the history of how the values(in our cases it will be address) were previously copied. (It must be getting irritating for today,so stop here for today) We will be seeing 3 cases A,B,C in each we will have 3 cases 1,2,3 (caseA) (caseB) (caseC) class interface array c i a \ | / \ | / \ | / \ | / (0) case A:somebody wants to copy address from c (c of type class e.g Button b) case B:somebody wants to copy address from i (i of interface type e.g ActionListener b) case C:somebody wants to copy address from a (a of array type e.g Button[] b) in each we have 3 cases: case 1 means that somebody is a class case 2 means that somebody is an interface case 3 means that somebody is an array (remember somebody is always on the left side of "=" in assignment because it is getting the value of address) [B]case A:somebody wants to copy from a_class_type; //i.e wants to point to object [/B]and we hav 2 see when it is valid Case 1:somebody is another class e.g Button b=new Button("Click me"); Object o;//somebody is Object; o=b; is valid rule->this case is valid if somebody is a superclass of b; i.e only a superclass can copy address from a class another_class2(should be superclass of class1 if it wants \ copy value from class1) \ \ \ \ class1------------(0) (note i have used class1 and another_class2 just to make the diagram simple they are actually variables e.g it can be b not Button also note if another_class2 is not a superclass of class1 then it only means that another_class2=class1 will not be valid but if there is any other class(class2) which is pointing to the object and also subclass of another_class2 then another_class2=class2 is valid) Case 2:somebody is an interface e.g Button b=new Button("Click me"); some_interface i;//somebody is some_interface; rule->this case is valid if the class implements somebody interface interface1(should be implemented by class1 if it wants \ 2 copy value from class1) \ \ \ \ class1----------(0) Case 3:somebody is an array rule->this case is [B]NOT[/B] valid under any circumstances(good [img]http://www.javaranch.com/ubb/smile.gif[/img]) [B]case B:somebody wants to copy from an_interface[/B] //to check if this is valid Case 1:somebody is another class ActionListener al; Object o;//somebody is Object; o=al; is valid rule->this case is valid [B]only[/B] if somebody is of type Object. class(should be of type Object only,if it wants 2 \ copy value from interface) \ \ \ \ interface-------(0) Case 2:somebody is an interface (this is similar to case A case 1) an_interface's_superInterface=an_interface//only this is valid rule->this case is valid if the somebody interface is super interface of an_interface; Case 3:somebody is an array rule->this case is [B]NOT[/B] valid under any circumstances [B]case C:somebody wants to copy from an_array_type[/B] //to check if this is valid Case 1:somebody is another class ActionListener al; Object o;//somebody is Object; o=al; is valid rule->this case is valid [B]only[/B] if somebody is of type [B]Object[/B] Case 2:somebody is an interface (this is similar to case A case 1) someInterface=array_type rule->this case is valid only if the someInterface is of type [B]Cloneable or Serializable[/B] Case 3:somebody is an array e.g. Component[] c; Button[] b=new Button[100]; c=b;//** for a moment forget they are arrays Component c; Button b=new Button(); c=b; is this valid ?? yes by rule case A case1 (since Component is a superclass of Button)hence we conclude that conversion with ** is valid. All this is summarized in a table on page 115 in RHE now also see examples in RHE [/font]
(i guess i am a very bad writer )

[This message has been edited by leena rane (edited November 10, 2001).]

Dear all,
Frankly speaking,i draw diagrams to take decisions whether
an object ref. conversion or casting is valid or not.I am
finding it difficult to put it in words
(I can explain it within no time to a person sitting next to
me).I have put my best efforts but still am not satisfied
whether it will be easy to understand.Please give me feedback,
which part i have not written clearly,i will quickly try to
better it.Also this is not a topic which you should try to
grasp in 15 minutes.Take breaks in between otherwise it will
be very boring.
regards,
leena
(next message is about obj. ref. conversion)
(after that is obj. ref. casting)
all the best

Congrats Rashmi
All the best 4 ur future
regards,
leena