Re: 'super...to refer to a variable of the superclass'
Fred wrote:
Cadenhead in "Sams Teach Yourself Java 2 in 24 hours" writes that
'super...can be used...to refer to a variable of the superclass, as in
super.hawaii = 50.'
I don't understand why this is in general, possible. If an instance of
the subclass has been created, it cannot be assumed that an instance
of the superclass has been simultaneously created.
Arne Vajh??j wrote:
Yes.
The object created is both an instance of the sub class and the
super class.
To clarify: it is the same instance that is created, so of course it's
"simultaneous" because it's the identical object. An object is always created
at the same time as it itself is created. Thus it is safe to conclude (not
assume) that an instance of the supertype (it might not be a class) exists.
Fred wrote:
If an instance of
the superclass has not been created, then the above statement doesn't
make sense. The assumption is that the hawaii variable is static,
right?
Arne Vajh??j wrote:
No.
Fred wrote:
And I don't understand why an assignment to a superclass's variable
would *ever* need to be made *by* the subclass. If the variable is not
Because it is the instance's own variable, too.
(Unless it's private, or package-private from a different package.)
static, the variable has been inherited - playing around with that
Unless it's private, or package-private from a different package.
'copy' of the variable should suffice for all purposes, should it not?
Arne Vajh??j wrote:
Yes - you can simply write:
hawaii = 50;
but it is not a 'copy' - it is the real thing.
You can need to use:
super.m();
when you don't want to call the sub class's m method
(which is often the case if the call is inside
the sub class's m method).
Using 'this.' or 'super.' in front of variable names is necessary to
disambiguate member variables from local variables or hidden or shadowed
variables, which name conflicts you should avoid anyway.
Fred, the thing to bear in mind is what Arne mentioned:
> The object created is both an instance of the sub class [type] and the
> super class [type].
That is why you can (and usually should) declare variables as the supertype
(preferably an interface) and instantiate as the subtype (class):
List <Foo> foos = new ArrayList <Foo> ();
The object pointed to by 'foos' is both an 'ArrayList' and a 'List' (and an
'AbstractList' and a 'Cloneable' and an 'Iterable' and a 'Collection' and a
'RandomAccess' and a 'Serializable' and an 'AbstractCollection' and an
'Object', while we're about it).
<http://download.oracle.com/javase/6/docs/api/java/util/ArrayList.html>
An instance of a 'javax.management.AttributeList' is all of those things as well.
--
Lew
Ceci n'est pas une pipe.