Inheritance is a hierarchical relationship set up between two classes called a derived class, subclass, or child class, and a base class, superclass, or parent class.
Inheritance is set up in the derived class declaration using the extends keyword.
One of the benefits of inheritance is that the derived class automatically inherits — gets access to — members of a base class, subject to visibility modifier constraints.
If an attempt is made to access a method or instance variable of a derived class that is in an inheritance relationship, and the derived class does not have a suitable implementation of that variable or method, Java will search up the hierarchy in an attempt to find a suitable method or instance variable implemented by one of its inherited base classes.
The first suitable member found while searching up a hierarchy will be accessed.
When a derived class defines a member that matches one defined in a base class, it is said that the derived class member overrides the base class member.
The scope of a base class may be specified explicitly using the super keyword.
Derived class constructors must invoke base class constructors as part of the derived class constructor implementation. This may be accomplished using the super keyword.
Base class methods may be invoked explicitly from within an object, skipping an overridden implementation in the derived class, by using super as the method’s scope.
A method defined in a derived class may overload a base class method if the method names are the same but the signatures differ.
Inheritance is often referred to an is-a relationship because the derived class is a kind of base class.
An object of type derived class may be assigned to a variable of type base class. This is a form of polymorphism found in Java and it is an implication of the inheritance relationship.
Due to polymorphism, it is permitted to pass an argument of type derived class to a method whose parameter declaration is of type base class, as well as to store multiple types of derived classes in an ArrayList declared to store objects of a common inherited base class type.
When a program invokes a method on an object of type derived class using a variable of type base class, the method implementation in the derived class is invoked. This is called dynamic binding.
The particular methods invoked are governed by the type of the object referenced by a variable, not the type of object variable.
The Java compiler will not permit the invocation of methods defined by a derived class and not in a base class if the invocation is attempted on a variable of type base class, even if it references an object of type derived class.
If a base class member is intended to be accessed only by itself and its derived classes, and not to be made generally accessible by any external class, the member may be declared using the protected visibility modifier. Compare to public and private visibility modifiers.
Another benefit of inheritance is that it allows the program designer to group common members in a base class, making them accessible to all derived classes, reducing code duplication.
Defining derived classes with unique state and behavior is a kind of specialization
Overriding methods to replace functionality is one way to specialize a derived class
Overriding methods to augment functionality is another way to specialize a derived class
Inheritance may be prevented by modifying the declaration of a class with the final modifier
All classes ultimately inherit the Object class, even if the extends keyword is not used.
Several useful methods are inherited by all classes from Object, including equals(…) and toString()
The == operator tests two objects for equal identity, which is not always the desired behavior. Sometimes the notion of equality is different than object identity. For example, String objects should be considered equal when their character sequences are identical, even when the String objects themselves are distinct.
The default behavior of Object’s equals(…) method is to test for object identity. The String class overrides equals(…) to replace the Object implementation with an implementation that tests characters sequence for equality.
When printing an object, the println(…) method of the PrintStream class invokes an object’s toString() method to obtain a String representation of an object which is printed to the output stream. This is possible because the Object class provides a default implementation of toString() to all Java classes through inheritance.
It is often useful to override toString() in a custom class to provide a more informative String representation that is printed by println(…).
The instanceof operator is a useful way to test if one object is an instance of a class. The instanceof operator takes inheritance into account; it will return true when testing if a derived class in an instance of a base class due to the nature of the inheritance relationship.
An object of type derived class referenced by a variable of type base class may be cast to a derived class type using a cast (…). Often this is necessary when the object must be accessed as its original derived class type, such as when invoking a method implemented in the derived class only, and when passing as a parameter to a method requiring the derived class type.
When a class should not be instantiated, declare it as abstract.
Abstract classes serve to collect common behavior to be inherited by derived classes even though abstract base classes cannot be instantiated.
Abstract classes also are useful as inherited types that may reference objects of any derived class type.
