Re: Behavior of OO
On Nov 28, 12:20 am, Philipp <sicsic...@freesurf.ch> wrote:
Hello
I have a somewhat naive question about OO.
If you have two classes Fruit and Apple extends Fruit. You declare:
Fruit f = new Fruit();
Fruit a = new Apple();
f.eat();
a.eat();
if you call the method .eat() on f, you get the eat() from Fruit and if
you call eat() on a, you get the overriden eat() behavior in Apple.
On the other hand, if somewhere else, the following two methods are
defined:
public void makeJam(Fruit f){};
public void makeJam(Apple a){};
and you call makeJam(f) and makeJam(a), both times it's the
makeJam(Fruit) which is called.
So in one case, the runtime "knows" that the object is actually an Apple
although it was declared a Fruit, and makes a distinction by calling the
correct method. In the other case it does not make the distinction. (yes
I know I could check with instanceof and cast)
Why is this so? Is this a design choice in the language? Or is it for
performance reasons? Are there cases when having it the other way (ie.
chosing the method signature which best fits the arguments) would lead
to UB?
It's a design choice of the Java language, inherited from its
predecessors (C++, Smalltalk, and various others). Method virtual
dispatch is only performed against the implicit zeroth argument,
"this"; the remaining arguments' *static* types are used to determine,
at compile time, what the signature of the method to dispatch is.
There are languages that do multiple dispatch; Haskell does it via its
pattern-matching mechanism, but it's by no means the first. Even the
Common Lisp Object System has support for multiple dispatch.
While I have no particular insight into why Java's design uses single-
dispatch from a technical standpoint, I do find it easier to read code
in single-dispatch object systems than code for multiple-dispatch
systems. It's also a much more common system; for a language designed
for The Masses that makes it more likely any random programmer already
understands the method dispatch system before coming to Java.
There are times when multiple dispatch leads to nicer code. The
Visitor pattern is a simplistic way to emulate multiple dispatch in a
single-dispatch language; it's all but unnecessary when you can match
calls to method bodies based on the dynamic types of the arguments,
for example.
-O