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

equire that we override the drink method, as all dogs drink pretty much the
same way. But it could require that we override the sniff method, as a
Bloodhound has a much more sensitive sense of smell than a standard dog. In this
way, the Bloodhound class specializes the methods of its superclass, Dog.
Extension
In using extension, on the other hand, we utilize inheritance to reuse the code
written for methods of the superclass, but we then add new methods that are not
present in the superclass, so as to extend its functionality. For example, returning
to our Dog class, we might wish to create a subclass, BorderCollie, which
inherits all the standard methods of the Dog class, but then adds a new method,
herd, since Border Collies have a herding instinct that is not present in standard
dogs. By adding the new method, we are extending the functionality of a standard
dog.
In Java, each class can extend exactly one other class. Even if a class definition
makes no explicit use of the extends clause, it still inherits from exactly one
other class, which in this case is class java.lang.Object. Because of this
property, Java is said to allow only for single inheritance among classes.
Types of Method Overriding
Inside the declaration of a new class, Java uses two kinds of method overriding,
refinement and replacement. In the replacement type of overriding, a method
completely replaces the method of the superclass that it is overriding (as in the
sniff method of Bloodhound mentioned above). In Java, all regular methods
of a class utilize this type of overriding behavior.
In the refinement type of overriding, however, a method does not replace the
method of its superclass, but instead adds additional code to that of its superclass.
In Java, all constructors utilize the refinement type of overriding, a scheme called
constructor chaining. Namely, a constructor begins its execution by calling a
constructor of the superclass. This call can be made explicitly or implicitly. To
call a constructor of the superclass explicitly, we use the keyword super to refer
to the superclass. (For example, super() calls the constructor of the superclass
with no arguments.) If no explicit call is made in the body of a constructor,
however, the compiler automatically inserts, as the first line of the constructor, a
call to super(). (There is an exception to this general rule, which is discussed
in the next section.) Summarizing, in Java, constructors use the refinement type of
method overriding whereas regular methods use replacement.
The Keyword this
100