Data Structures and Algorithms in Java[1].pdf - Fulvio Frisone

comparability feature to a class (imposing a natural order on its instances), and
java.util.Observer, which adds an update feature to a class that wishes to
be notified when certain "observable" objects change state.
2.4.3 Abstract Classes and Strong Typing
An abstract class is a class that contains empty method declarations (that is,
declarations of methods without bodies) as well as concrete definitions of methods
and/or instance variables. Thus, an abstract class lies between an interface and a
complete concrete class. Like an interface, an abstract class may not be instantiated,
that is, no object can be created from an abstract class. A subclass of an abstract
class must provide an implementation for the abstract methods of its superclass,
unless it is itself abstract. But, like a concrete class, an abstract class A can extend
another abstract class, and abstract and concrete classes can further extend A, as
well. Ultimately, we must define a new class that is not abstract and extends
(subclasses) the abstract superclass, and this new class must fill in code for all
abstract methods. Thus, an abstract class uses the specification style of inheritance,
but also allows for the specialization and extension styles as well (see Section 2.2.3.
The java.lang.Number Class
It turns out that we have already seen an example of an abstract class. Namely, the
Java number classes (shown in Table 1.2) specialize an abstract class called
java.lang.Number. Each concrete number class, such as
java.lang.Integer and java.lang.Double, extends the
java.lang.Number class and fills in the details for the abstract methods of
the superclass. In particular, the methods intValue, floatValue,
doubleValue, and longValue are all abstract in java.lang.Number.
Each concrete number class must specify the details of these methods.
Strong Typing
In Java, an object can be viewed as being of various types. The primary type of an
object o is the class C specified at the time o was instantiated. In addition, o is of
type S for each superclass S of C and is of type I for each interface I implemented
byC.
However, a variable can be declared as being of only one type (either a class or an
interface), which determines how the variable is used and how certain methods
will act on it. Similarly, a method has a unique return type. In general, an
expression has a unique type.
By enforcing that all variables be typed and that methods declare the types they
expect and return, Java uses the technique of strong typing to help prevent bugs.
But with rigid requirements on types, it is sometimes necessary to change, or
121