8.1 Introduction

In this chapter we will learn about inheritance, one of the key characteristics of object oriented languages.  Object oriented programming languages support reuse. After we design an object to use in one program, we may find that we can reuse it in another program. We can also extend the class to add new capabilities rather than just reusing the class.

8.2  Inheritance

Inheritance is a way to add functionality to a class without changing the underlying class. A class that is inheriting is subclass ( also a child class or derived class or extended class. The class from which the subclass is derived is called a superclass (also a base class or a parent class).

General form of inheritance is:

class newclass extends existingclass // newclass is child class and existing class is parent (super) class

Example

class sss extends s;  //sss  is subclass and s is superclass.

Program8.1  Program to demonstrate inheritance.

// inheritDemo.java

//click here for code

import java.io.*;

class inheritDemo

{

  public static void main (String args[])

  {

   arithmetic ar = new arithmetic ();

   System.out.println ("the variables n1 and n2 are in sumdiff b");

   System.out.println ("n1 = "+ar.n1);

   System.out.println ("n2 = "+ar.n2);

   ar.n3 = ar.mul ();

   System.out.println ("result after multiplication "+ar.n3);

   ar.n3 = ar.sum ();

   System.out.println ("result after add b "+ar.n3);

   ar.n3 = ar.diff ();

   System.out.println ("result after diff b "+ar.n3);

   ar.n3 = ar.div ();

   System.out.println ("result after div b "+ar.n3);

  }

}

class sumdiff
{
  int n1, n2;
 
 public sumdiff ()//constructor

  {

   n1 = 15;

   n2 = 10;

  }

  public int sum ()

  {

 int n3;

 n3 = n1 + n2;

 return n3;

  }




  public int diff ()

  {

 int n3;

 n3 = n1 - n2;

 return n3;

  }

}




// arithmetic inheriting from sumdiff

class arithmetic extends sumdiff

{

  int n3;

  public int mul ()

  {

 int n3;

   n3 = n1 * n2;

   return n3;

  }

  public int div ()

  {

 int n3;

 n3 = n1 / n2;

 return n3;

  }

}




/*

Output:

the variables n1 and n2 are in sumdiff b

n1 = 15

n2 = 10

result after multiplication 150

result after add b 25

result after diff b 5

result after div b 1

*/

In the above program, sumdiff is a class with two methods sum() and diff(). We defined another class arithmetic that inherited n1, n2 and sum(), diff() methods.

We added two more functions mul() and div(). Now, we can access all four methods. We need not write another constructor for arithmetic.

Java always calls the constructor of the superclass even if we include a constructor in subclass.

A class member that has been declared as private will remain private to its class.

8.3 Super class and subclass

8.3.1 Super class

Super class is the parent class from which other classes can be derived.

The this keyword refers to the parent class, that is the super class. When we override methods of a super class we replace the methods with efficient methods. Sometimes, we want to retain this super class methods and also extend their functionality.

If we override and yet require the methods of a super class we then will have to re-code the methods. But if we want to reuse existing methods of the superclass and also want to add more functionality to the existing methods, we use the keyword super. With this word we can refer the data and methods of the parent class even if they have been overridden.

The call to the super must be the first time in the constructor of the subclass.

A reference variable of a superclass can be assigned to any subclass derived from that superclass.

In a hierarchy of classes, controller are called in order of derivation, from superclass to subclass.

8.3.2 Subclass

A class that inherits from other class automatically  includes essentially all of the methods and fields of the class that it inherits from. A subclass inherits all the members (fields, methods, and nested classes) from its superclass. Constructors are not members, so they are not inherited by subclasses, but the constructor of the superclass can be invoked from the subclass [8.1].

//superDemo.java
//click here for code
class candidate
{ //super class
int id;
String name;
candidate (int id, String name)
  {
this.id = id;
this.name = name;
} 
} 

class student extends candidate
{ //child class
int marks;
student (int id, String name, int marks)
  {
   super (id, name);//parent or super class constructor  
   this.marks = marks;
} 

void display ()
  {
   System.out.println (id + " " + name + " " + marks)
} 
} 

class superDemo
{
public static void main (String[]args)
  {
   student stud = new student (1001, "Ramu", 97);
   stud.display ();
}}

/* Output:

1001 Ramu 97

*/

Program 8.3. Program to demonstrate the use of the keyword super.

//x.java
//click here for code
public class x extends y
{
  int a = 1;
  int b = 2;
  public static void main (String args[])
  {
   x xobj = new x ();
  }

  public x ()
  {
   super.sum (a, b);
   super.diff (a, b);
   super.mul (a, b);
  }
}

class y
{
  public static void sum (int a, int b)
  {
   System.out.println ("sum=" + (a + b));
  }
  public void diff (int a, int b)
  {
   System.out.println ("diff=" + (a - b));
  }
  public static void mul (int a, int b)
  {
   System.out.println ("mul=" + (a * b));
  }
}

/* Output:
sum=3
diff=-1
mul=2
*/

8.4 Multiple inheritance

If we want to create a class that inherits from multiple classes, then this is called multiple inheritance. Java does not support multiple inheritance. As an alternative to multiple inheritance, Java provides interface, We will learn about interfaces in the next chapters.

Program 8.4 Program to demonstrate function inheritance.

//myclass.java
//click here for code
class p1
{
  p1( ){
  System.out.println("inside p1");
 }
}

class p2 extends p1
{
p2(){
System.out.println("inside p2");
}
}

class p3 extends p2
{
p3(){
System.out.println("inside p3");
}
}

class myClass
{
public static void main(String args[])
{
 p3 c =new p3();
}
}

/*
Output:
inside p1
inside p2
inside p3
*/

Program 8.5 Program to define a super class student, which will be used in the next program 8.6. Just compile this program. Do not execute.

//istudent.java

//click here for code
import java.io.*;
import java.util.*;
public class istudent
{
String name;
int regdno;

public istudent()
{
name=" ";
regdno=0;
}

public void getdata()
{
try{
DataInputStream in=new DataInputStream(System.in);
System.out.println("enter student name");
name=in.readLine();
System.out.println("enter register number");
String k=in.readLine();
regdno=Integer.parseInt(k);
}
catch(Exception e)
{
System.out.println("I/O error"+e);
System.exit(1);
}
}
}

Program 8.6. Program that inherits from istudent class defined above. Compile the above program 8.5 and run this program.

//year1.java

//Click here for code

import java.io.*;
import java.util.*;
public class year1 extends istudent
{
int a[]=new int[10];
float per;
public year1()
{
super();
per=0;
}

public void getdata(int n)
{
int sum1=0,x=0;
getdata();
try{
DataInputStream in;
in=new DataInputStream(System.in);
System.out.println("enter the marks");
sum1=0;
String k;
for(int i=0;i<n;i++)
{
k=in.readLine();
x=Integer.parseInt(k);
a[i]=x;
sum1=sum1+a[i];
}
per=(float) (sum1/n);
}
catch(Exception e)
{
System.out.println("I/O error"+e);
System.exit(1);
}
}
public static void main(String args[])
{
int m=0,n=0;
year1 first[]=new year1[10];
try
{
DataInputStream in;
in=new DataInputStream(System.in);
System.out.println("enter the number of subjects");
String s=in.readLine();
n=Integer.parseInt(s);
System.out.println("enter the number of students");
s=in.readLine();
m=Integer.parseInt(s);
}
catch(Exception e)
{
System.out.println("I/O error"+e);
System.exit(1);
}
for(int i=0;i<m;i++)
{
first[i]=new year1();
first[i].getdata(n);
}

for(int i=0;i<m;i++)
System.out.println(first[i].name+" "+first[i].regdno+" "+first[i].per);
}
}

/* 
Output:
enter the number of subjects
5
enter the number of students
4
enter student name
Amar
enter register number
10
enter the marks
70
78
67
80
90
enter student name
Sunil
enter register number
11
enter the marks
71
69
75
56
89
enter student name
Badri
enter register number
12
enter the marks
72
70
67
59
92
enter student name
Chand
enter register number
14
enter the marks
70
71
89
56
78
Amar 10 77.0
Sunil 11 72.0
Badri 12 72.0
Chand 14 72.0
*/

8.5 Overriding methods

Some times we may want to modify the functionality of an existing method in a given super class. We override the method that is, we change the functionality of a subclass. We do overriding by creating a new method with the same name as the overridden method. When an overridden method is called from a subclass, it will always refer to the version of that method defined by the subclass. The previous version of the method defined by the super class will be hidden.

Program 8.7. Program to demonstrate overriding.

//overRide.java
//click here for code
class p1
{
  int i, j;
  p1 (int a, int b)
  {
    i = a;
    j = b;
  }
  //method show() prints i and java
  void show(){
      System.out.println("i="+i+"j="+j);
  }
  }

class p2 extends p1
{
    int k;
    p2(int a, int b, int c){
        super(a,b);
        k=c;
    }

    //the following show() function overrides show() of p1
    void show(){
        System.out.println("k:="+k);
    }
}

class overRide{
    public static void main(String args[]){
        p2 ex=new p2(1,2,3);
        ex.show(); //this execures p2 show()
    }
}

/*
Output
k:=3
*/