On 7??27??, ????12??17??, "Peter Duniho" <NpOeStPe....@nnowslpianmk.com>
wrote:
On Sat, 26 Jul 2008 20:07:55 -0700, gg9h0st <g9h...@gmail.com> wrote:
ooooooooowwwww~~ I still don't get it :S
that "a subclass of S might" part.
so compiler doesn't know what variable 'b' hold? that is oviously
ClassB.
There are things that are obvious to a human reader that are not obvious
to the compiler.
The case you're talking about is a degenerate case, but there are similar
situations in which analysis of the execution of the code _could_ prove
that the cast would succeed or fail, but such analysis would be _much_
more complicated than simply looking at the initialization of the variable.
For a variety of reasons, but I think mainly just to keep things
consistent (consistent, predictable compiler behavior is always a nice
thing :) ), the compiler is simply going to assume that all such casts are
valid. It's not feasible to verify them in all cases, and so rather than
provide inconsistent behavior, the compiler doesn't bother to verify them
in any case. It's up to you, the author of the code, to not perform casts
that will fail.
Basically: pretend you're a compiler. Look at _just_ the statement being
compiled. Based solely on that statement and _statically_ known things
(e.g. the types of the identifiers in the statement), can you prove that
the cast is valid or invalid?
The answer to that question is "no". And that's exactly why the compiler
can't prove it either.
Pete
yea T_T
I spend so much time to digging it.
what you explained me makes me somehow easy. need to sleep lol
I just found that doesn't make an error while casting class on an
incompatible hierarchy makes an error.
and wanted to know.
( ClassB extends ClassA, ClassD extends ClassC,
casting ClassD to ClassB issues an error.
while ClassB implements InterfaceA, ClassD implements InterfaceD,
casting ClassD to ClassB doesn't.)
I better leave it to "compiler does like this" and move to the other
studies as a newbie.
thanks :)
where ClassD to InterfaceA would not. The compiler can not disprove the
existance of ClassE extends ClassD implement InterfaceA. ClassE might