Implementing Inheritance in Java Example

Inheriting a superclass gives the ability to a subclass to define only those aspects that differ from or extend the functionality of the superclass. The syntax for creating a subclass is simple. At the beginning of your class definition, use the extends keyword after the class name followed by the name class being extended (i.e. superclass). A subclass can only inherit directly from one superclass. Unlike C++, Java does not support multiple inheritances.

class SubClassName extends SuperClassName

{

// Additional member declarations

}

Here, SubClassName is the name of the subclass and SuperClassName is the name of the superclass whose members are inherited by subclass. The extends keyword identifies that SuperClassName is the superclass for class SubClassName. This keyword establishes an inheritance relationship between the two classes. The body of the subclass contains the members declaration for all the members that are not common to that of the superclass.

The member that is inherited in the subclass is a full member of that class and is freely accessible to any method in the class .When object(s) of the subclass are instantiated, it will not only contain the members of its class but also contain all the inherited members of the superclass from which it is derived.

In order to understand how a subclass is derived from the superclass, let us consider a program having a superclass named Base that consists of a data field numl and a method

baseShow () . Suppose you want to extend the functionality of Base by adding new members. For this, we create subclass named Derived which is derived from the Base. So it inherits all the accessible members of the Base. It also extends the functionality of the Base by adding its own field num2 and methods product () and derivedShow(). These members are exclusive to the subclass and cannot be used by the object of the superclass.

class Base 
 { 
       int num1; 
       void baseShow() 
       { 
         System.out.println("num1 = " + num1); 
       } 
 } 
       //subclass of Base class 
       class Derived extends Base 
      { 
             int num2; 
             void product() 
           { 
                System.out.println("product = " + (num1 * num2)); 
            } 
              void derivedShow() 
           { 
               System.out.println("num2 = " + num2); 
           } 
      } 
 public class ImpInheritance 
 { 
      public static void main(String[] args) 
      { 
           Derived d = new Derived(); 
           d.num1 = 20 ; 
           d.baseShow(); 
           d.num2 = 10 ; 
           d.derivedShow(); 
           d.product(); 
       } 
 } 
 

The above program explains how a class can be derived using inheritance. Here, class Base is the superclass and class Derived is its subclass. In the class header, ‘Derived extends Base’ means that the class Derived implicitly inherits the data fields and methods of class Base. In other words, we can say that class Derived inherits the field numl and the method baseShow () from the class Base. So these members are freely accessible to any method of the class Derived as if they are members of that class. This can be seen in the method product () of the class ‘Derived’ where numl field of class Base is referred directly.

In the main () method, when the Derived object is created, it can access both numl and

num2fields as well as can call methods baseShow () , derivedShow () and product () .