Re: What do use instead of overriding static methods?
Jim T wrote:
I'm extremely new to java, so I'm sure this has been asked before.
Please bear with me. Also please pardon any typos in my pseudocode.
Coming from Objective-C land, I have a class hierarchy and a bunch of
methods that basically amount to this:
There's a lot I don't understand about your example. Some is
probably because you're writing in a patois that's neither Java nor
Objective-C, some may just be carelessness. I'll try my best to
follow along, but expect no miracles.
class SuperClass {
Vector loadFromDatabase {
SomeVariable myType = CLASS.myType();
It seems all the myType() methods are declared as returning an
`int' value, so `SomeVariable' had better be `int' (or `long' or
`float' or `double'). I'm not sure if the disagreement is supposed
to mean something or not.
//load stuff up in an interesting manner
//return my vector
}
static int myType {
System.out.println("OH NOES!");
Java won't allow this: A method that's declared as returning
an `int' (or an `X') must actually do so. You can't just fall
off the end.
}
}
class Subclass1 extends SuperClass {
static int myType {return "foo"; };
... nor can an `int'-valued method return a `String'.
}
class Subclass2 extends SuperClass {
static int myType {return "bar"; };
}
class Subclass3 extends SuperClass {
static int myType {return "baz"; };
}
//inside some method
Vector stuff = Subclass1.loadFromDatabase();
Essentially, the routine to load from the database is identical for
all subclasses, the only thing that needs to vary is what type of
object is getting loaded, and that's defined as a class method in the
subclass. All works wonderfully well in Objective-C, but, of course, I
have access to a class variable there (in an instance method "self" is
the object, in a static method, "self" is the class itself), so it's
easy to do.
And I'm just at a loss for a java-ish way to do this. I could define
some sort of lookup table in the superclass, but that's silly - and
requires the superclass to know which subclasses it has. But I can't
figure out any other way to do it. Once I'm in the loadFromDatabase()
method, it always seems to call SuperClass's myType().
So how can I implement this cleanly?
One way would be to pass an argument to loadFromDatabase(). I
can't tell from your pseudocode whether the argument ought to be an
`int' or a `Class' or perhaps something else.
Your insistence on using static methods seems peculiar, and
may be the cause of some of your conceptual difficulties.
While I'm at it, is there any way to dynamically choose a class to
call a class method upon? Again, in objective-C, you can do:
[[self class] someClassMethod];
So I'd think that the java equivalent would be:
this.getClass.someClassMethod();
But, alas, that doesn't seem to work either. Is this possible? And, if
so, how?
It's possible, through a mechanism called "reflection." You can
get the `Class' object from any instance (it's a little clumsier to get
it in a static context), and then you can find the Method object for
the method you want to call, and then you can construct an execute a
call to the method.
But you don't want to.
You only *think* you want to, because you're trying to force the
idioms of one language onto another. "The determined Real Programmer
can write FORTRAN programs in any language." Your life will be more
productive, your existence calmer, and your disposition unruffled if
you'll instead learn Java on its own terms instead of trying to
transliterate from a different language.
--
Eric.Sosman@sun.com