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

An Arithmetic Progression Class
Next, we consider the class ArithProgression, which we present in Code
Fragment 2.3. This class defines an arithmetic progression, where the next value
is determined by adding a fixed increment, inc, to the previous value.
ArithProgression inherits fields first and cur and methods
firstValue() and printProgression(n) from the Progression
class. It adds a new field, inc, to store the increment, and two constructors for
setting the increment. Finally, it overrides the nextValue() method to conform
to the way we get the next value for an arithmetic progression.
Polymorphism is at work here. When a Progression reference is pointing to
an Arith Progression object, then it is the ArithProgression methods
firstValue() and nextValue() that will be used. This polymorphism is
also true inside the inherited version of printProgression(n), because the
calls to the firstValue() and nextValue() methods here are implicit for
the "current" object (called this in Java), which in this case will be of the Arith
Progression class.
Example Constructors and the Keyword this
In the definition of the Arith Progression class, we have added two
constructors, a default one, which takes no parameters, and a parametric one,
which takes an integer parameter as the increment for the progression. The default
constructor actually calls the parametric one, using the keyword this and
passing 1 as the value of the increment parameter. These two constructors
illustrate method overloading (where a method name can have multiple versions
inside the same class), since a method is actually specified by its name, the class
of the object that calls it, and the types of arguments that are passed to it—its
signature. In this case, the overloading is for constructors (a default constructor
and a parametric constructor).
The call this(1) to the parametric constructor as the first statement of the
default constructor triggers an exception to the general constructor chaining rule
discussed in Section 2.2.3. Namely, whenever the first statement of a constructor
C ′ calls another constructor C ″ of the same class using the this reference, the
superclass constructor is not implicitly called for C. Note that a superclass
constructor will eventually be called along the chain, either explicitly or
implicitly. In particular, for our ArithProgression class, the default
constructor of the superclass (Progression) is implicitly called as the first
statement of the parametric constructor of Arith Progression.
We discuss constructors in more detail in Section 1.2.
104