Re: [General]acces of members of subclass
Lew wrote:
Daniel Moyne wrote:
So Lew as superclasses cannot acces subclass members (in you example you
just provide methods "bar" in the subclass sub but no members) there is
no reasons to declare them as public and then only private makes sense ;
am I correct ?
Good question.
First a terminology point: both methods and fields are "members" of a
class,
or instance. Fields are also sometimes called "attributes", especially
when associated with getter and setter methods ('getFoo()' and 'setFoo(
value )').
Anyhow, the method 'bar()' in my example is a member of 'Sub', and makes
the
same point that a field member would - that subclass members can and often
should be public, or protected, not necessarily private.
So 'private' access makes sense for the explicit purpose of hiding
implementation, one of those Good Things you hear about. However, some
members, usually just methods and not fields, will have wider access than
that. If you want to make a field public, it is legal if not always
desirable to do so.
The reason to declare a subclass member 'public' is to give it wide access
to all users, but those users will have to declare their variables *to the
subclass type* to benefit from those members.
So in the upthread example:
===================
public class Super
{
public void foo() { ... }
}
public class Sub extends Super
{
public void bar() { ... }
}
public class Client
{
public void main( String [] args )
{
Super sup = new Sub();
sup.bar(); // illegal!
}
}
===================
the class 'Client' made a mistake - it used a superclass variable but it
wanted subclass functionality. It is not enough that the method is public
-
the variable has to be aware of it, too. Like this:
===================
public class Client
{
public void main( String [] args )
{
Sub sub = new Sub();
sub.bar(); // legal!
}
}
===================
Variables are doorkeepers to the real objects, not the objects themselves.
They only let through the references that are on their list, and if you're
not on the list, you don't get in.
Now coming back to method "bar" I have seen in the net some java code
based on method :
getMethod
and then invoke
that would allow to access this method from outside of the subclass but I
could not find this back for this topics.
You are probably referring to polymorphism and method overrides. This
would
apply to the method 'foo()' in the example, but not to fields. Once the
compile-time doorkeeper lets the call in, say to 'foo()', the actual
object
behind the door executes the call. Because the object's actual run-time
type is 'Sub', then it executes the subclass's version of the method.
This does not work for 'bar()' because the superclass variable doesn't
have awareness of that call to even let it through.
The access of method of subclass was not on my original post ; it was
only about access to members of subclass "Sub".
The exact same logic applies to member fields as member methods - the
variable
type must be aware of the member in order to refer to the member.
Supertype
variables cannot refer to subtype members. If you need awareness of the
subtype member, then the client code would declare the variable of the
subtype.
This is commonly done with 'ArrayList' as a subtype of 'List', for
example. Most of the time, one uses the 'List' type, but every so often
one needs the
specific characteristics of the subtype. At those times, the client
declares its variable 'ArrayList', or some other suitable specific type.
Great Lew for all theses clear explanations :
(1) first of all sorry for the use of "member" which is a direct translation
from French word "membre" that is for you "field", the other animals being
called "m??thodes" in French.
(2) then from what you very well explain I want to go back to this point
using this piece of code :
===================
public class Client
{
public void main( String [] args )
{
Super sub = new Sub();
sub.bar(); // legal!
Sub sub1 = new Sub();
sub1.bar(); // legal!
}
}
===================
So with theses instanciations you have 2 objects and consequently you are
still not able to access "bar()" member of object "sub" which is the main
question of my original post ; if we want to go a little bit further am I
right saying that :
- Sub class as an extended Super class may have a "super constructor" of its
own with its own parameters if of course Super has one (Super may have more
than one constructor and hereafter I talk only about the one I am
interested in) ; such "super constructor" must start with super(...)
- Sub may have itw own typical constructor with its own parameters where of
course super(...) is not present.
- both constructors are present in class Sub like this :
===================
public class Sub extends Super
// Sub class extends class Super
{
// super constructor of Sub class
Sub(parameters) {
//question 1 : all parameters are to be in coherency with constructor of
// class Super ?
//question 2 : can we say that here that this constructor overwrites Super
// class constructor (the one in coherency with parameters) ?
super(...); //first line of constructor
...;
}
// subclass constructor of Sub class
Sub(other_parameters) {
//other_parameters have normally no connections with fields of class Super
...;
}
...;
}
===================
So at the end of the day when you do :
Super sub = new Sub(parameters);
Sub sub1 = new Sub(other_parameters);
you end up with ENTIRELY different objects that are like "a" and "b" in :
int a=1;
String b="eee":
Thanks.