Java Reference
In-Depth Information
Java implements polymorphism through
dynamic binding
(also called
late binding
).
This means that the method to be executed is determined at run time during the
program execution.
Note that we can call the
toString
method on any object. Here is the reason.
In Java, we can invoke the
toString
method on any object. The reason is that
all classes inherit (directly or indirectly) from the
Object
class, which contains the
method
toString
as part of its public interface.
The
Object
class contains a default implementation of the
toString
method that simply
prints the address of the object (it actually prints a number that is associated with the
object because the address of the object can change during the execution, but this detail
is irrelevant to the programmer). This default behavior of the
toString
method can be
overridden in any class. Note that the
computeStrength
method is not defined in the
Object
class, which is the only superclass of the
FictionalCharacter
class. Therefore, we
have to define the method as an abstract method inside the
FictionalCharacter
class. If
the method is not defined inside the
FictionalCharacter
class, then the following code
will not compile.
FictionalCharacter tom;
...
System. out . println (tom. computeStrength() ) ;
The reason is that even though
tom
may actually point to an object that belongs to
a class that has the
computeStrength
method (e.g., the
Superhero
class), Java does not
know this at compile time and will not allow the program to compile.
As a last point in this section, we could have used the following code to print the
ArrayList characters
.
System. out . println ( characters ) ;
The reason is that the
ArrayList
class contains a
toString
method that prints the
ArrayList
. This method will be automatically called on the
ArrayList
. The method, in
turn, will call the
toString
method on each of the elements of the
ArrayList characters
.
However, we chose the previous syntax in order to explain how polymorphism works.
8.7 Interfaces and the
Comparable
Interface
Including the
computeStrength
method in the
FictionalCharacter
class is a valid
approach to allow the rest of the world to compare fictional characters. However, we seem
to be giving too much of our “secret sauce” away.
One rule of designing classes is that they should provide only the interface that
is needed by the outside world and should not provide any implementation-related
details. The reason is that these implementation-related details may change in the
future, but the interface of the class should remain constant.
