An interface is a way of describing what classes should do, without specifying how they should do it. A class can implement more than one interface. In Java, an interface is not a class but a set of requirements for the class that we want to conform to the interface. All the methods of an interface are by default public. So, it is not required to use the keyword public when declaring a method in an interface. Interfaces can also have more than one method. Interfaces can also define constants but do not implement methods. An interface is defined like a class. Its general form is:

 

access_specifier interface InterfaceName

(

Return-type Method-l(Parameters);

Return-type Method-2(Parameters);

Type variable-l=value;

Type variable-2=value;

Return-type Method-N(Parameters);

Type variable-N=value;

 

To make a class implement an interface, we must declare that the class intends to implement the given interface and we need to supply definitions for all methods using the implements keyword.

When an interface has been defined, any of the classes can implement that interface. The general form of the class that includes an implements clause is:

 

class classname extends superclass implements interface

{

//class body

}

 

If we say that the Employee class implements the Comparable interface, this can be written as:

 

                   class Employee implements Comparable

 

Interface is a fully abstract class. Using the keyword interface, you can easily define the interface. Interface classes specify what a class must do, instead of how to do it. Interface body contains the variables, but they are not counted as instance variables, and methods without any body, i.e. only the declaration of the methods are there.

 

Interface has to be implemented using implements keyword. If the interface is implemented in a concrete class then, in concrete class all the abstract method of the interface must be implemented. But if it is implemented in abstract class then only required methods have to be defined, others can be left, but in concrete class this abstract class will be extended, rest all the methods have to be implemented.

 

Interface works as a contract among the team members of a project. Some time there is a need to define fixed layout or model that has to be followed by everybody, yet each will have its own implementation, own code without bothering about the others code. They follow the same prototype. For example, a display 0 method can be a part of any class, but its definition will vary.

A class can extend one class and implements one or more interfaces simultaneously, the way how multiple inheritances can be possible in Java. An interface can extends any number of interfaces but one interface cannot implements another interface, because if any interface is implemented then its methods must be defined, and interface never has the definition of any method. Interface cannot be instantiated, but it can work as super class of any other class, so that, its reference variable can be created to store or refer to its sub-ordinate classes objects.

Implementation of Interfaces

The interface contains only method declarations. Interface does not allow the implementation of methods, so that method declaration is followed by a semicolon, but no braces. All methods declared in the interface are by default implicitly public, so no need to use public as prefix in declaration. Interface contains the data members as constants. These constant values are implicitly public, static, and final, these modifiers can be omitted.

 

Interface declaration can be headed by interface modifiers, those are as follows:

 

1. public
2. abstract
3. strict floating point

 

Syntax to declare an interface:

 

modifier interface_name {

return_type methodNamel(parameter-list);

return_type methodName2(parameter-list);

type final-varNamel = value;

type final-varName2 = value;

}

 

Example:

 

interface Abc

{

void displayMsg();

}

public class DemoInterface implements Abc

{

public void displayMsg()

{

System.out.println(“This is implemented method of Abc interface”);

}

}

An interface can extends any number of interfaces. A demonstration is given below.

 

interface A

{

// …

}

interface B extends A

{

II …

}

interface C

{

// …

}

interface D extends B, C

{

// …

}

 

interface E

{

 //

}

class Abc

{

// …

}

class Xyz extends Abc implements D, E

{

// …

}

The final keyword has the following uses in the inheritance.

        If you want the method must not be overridden then defined that method as final.

 

Example:

 

class Abc

{

final public void dispaly()

{

System.out.println(“I am in Abc”);

}

}

class Xyz extends Abc

{

public void dispaly()

{

System.out.println(“I am in Xyz”);

}

}

 

At the time of compiler will show the error message given in the image.

                          

If you want to prevent a class from being inherited then declare that as final.

 

Example:

 

final class Abc

{

public void dispaly()

{

System.out.println(“I am in Abc”);

}

}

class Xyz extends Abc

{

public void dispaly()

{

System.out.println(“I am in Xyz”);

}

}

 

At the time of compiler will show the error message given in the image.

                        

If you want to create a constant then also use final with the variable declaration.

The methods declare as final, compiler is free to make inline calls for those methods. If a small final method is called, the compiler copies the bytecode of the final method as inline code to the calling method. The final method calls are resolved at compile time called, early binding.

Java supports multilevel inheritance. In multiple, multilevel class hierarchies contain the layers of inheritance. But at each layer, a class is a subclass of the superc1ass of another, except the last layer. One pictorial representation of such concept is given below.

                                   

Example:

 

class Student

{

private int rollno;

private String name;

private String address;

public void storeDetails(int rno, String sname, String sadd)

{

rollno = rno;

name = sname;

address = sadd;

}

public void showDetails()

{

System.out.println(“ROll No :: ” + rollno);

System.out.println(“Name :: ” + name);

System.out.println(“Address :: ” + address);

}

}

class Test extends Student

{

protected int marksSubjectl;

protected int marksSubject2;

protected int marksSubject3;

protected int marksSubject4;

public void storeMarks(int ml, int m2, int m3, int m4)

{

marksSubjectl = ml;

marksSubject2 = m2;

marksSubject3 = m3;

marksSubject4 = m4;

}

public void showMarks()

{

System.out.println(“Marks of Subjectl :: ” + marksSubjectl);

System.out.println(“Marks of Subject2 :: ” + marksSubject2);

System.out.println(“Marks of Subject3 :: ” + marksSubject3);

System.out.println(“Marks of Subject4 :: ” + marksSubject4);

}

}

 

class Result extends Test

{

private int totalMarks;

private float percentage;

private char grade;

public void evaluateResult()

{

totalMarks = marksSubjectl + marksSubject2 + marksSubject3 + marksSubject4;

percentage = (totalMarks*100.00F/600.00F);

if (percentage >=50.00F)

grade=’D’;

else

if(percentage >=55.00F && percentage<=60.00F)

grade = ‘C’;

else

if (percentage >=61.00F && percentage<=70.00F)

grade = ‘B’;

else

if (percentage >=71.00F && percentage<=75.00F)

grade = ‘A’;

else

if (percentage >=76.00F && percentage<=85.00F)

grade = ‘H’;

else

grade = ‘S’;

}

public void showResult()

{

showDetails();

showMarks();

System.out.println(“Total Marks :: ” + totalMarks);

System.out.println(“percentage :: ” + percentage);

System.out.println(“Grade :: ” + grade);

}

}

public class Multilevellnheritance

{

public static void main(String ar[])

{

Result ob = new Result();

ob.storeDetails(1001, “Alice”, “New York”);

ob.storeMarks(135,130,132,138);

ob.evaluateResult();

ob.showResult();

}

}

 output

                      

There can be few problems in multilevel inheritance, if the classes are not properly designed by the designer, or proper keywords art\ not used.

 

1. How the superclass parameterized constructor will be called?
2. If superclass and subclass protected or public data members have same name then, superclass data member will be hidden. How to distinguish or to access the superclass data member in the subclass?
3. If subclass member methods have the same signature as the superclass member method then how to call the superclass member methods?

The super keyword is the solution of all the above problems, to refer to its immediate superclass. The super has two general forms as given below:

 

1. To call the superclass constructor
2. To access the hidden member of the superclass.

Example:

 

class Student

{

private int rollno;

private String name;

private String address;

public void storeDetails(int rno, String sname, String sadd)

{

rollno = rno;

name = sname;

address = sadd;

}

public void show()

{

System.out.println(“ROll No :: ” + rollno);

System.out.println(“Name :: ” + name);

system.out.println(“Address :: ” + address);

}

}

class Test extends Student

{

protected int marksSubjectl;

protected int marksSubject2;

protected int marksSubject3;

protected int marksSubject4;

public void test (int rno, String sname, String sadd,int ml, int m2, int m3, int m4)

{

super(rno,sname,sadd);

marksSubjectl = ml;

marksSubject2 = m2;

marksSubject3 = m3;

marksSubject4 m4;

}

 

public void show()

{

super.show();

System.out.println(“Marks of Subjectl :: ” + marksSubjectl);

System.out.println(“Marks of Subject2 :: ” + marksSubject2);

System.out.println(“Marks of Subject3 :: ” + marksSubject3);

System.out.println(“Marks of Subject4 :: ” + marksSubject4);

}

 

class Result extends Test

{

private int totalMarks;

private float percentage;

private char grade;

public void Result(int rno, String sname, String sadd,int ml, int m2, int m3, int m4)

{

super(rno,sname,sadd,ml,m2,m3,m4);

 

totalMarks = marksSubjectl + marksSubject2 + marksSubject3 + marksSubject4;

percentage = (totalMarks*100.00F/600.00F);

if (percentage >=50.00F)

grade=’D’;

else

if(percentage >=55.00F && percentage<=60.00F)

grade = ‘C’;

else

if (percentage >=61.00F && percentage<=70.00F)

grade = ‘B’;

else ,

if (percentage >=71.00F && percentage<=75.00F)

grade = ‘A’;

else

if (percentage >=76.00F && percentage<=85.00F)

grade = ‘H’;

else

grade = ‘S’;

}

public void show()

{

super.show();

System.out.println(“Total Marks :: ” + totalMarks);

System.out.println(“percentage :: ” + percentage);

System.out.println(“Grade :: ” + grade);

}

}

public class MultilevellnheritanceDemo2

{

public static void main(String arg[])

{

Result ob = new Result (1001, “Alice”, “New York“, 135,130,132,138);

ob.show ();

}

 

The above code show how to call the superclass constructor and how to call the superclass method if that signature is same as the subclass method signature.

 

Example:

 

class Abc

{

int i;

public Abc(int i)

{

this.i= i;

}

}

class Xyz extends Abc

 

{

int i,j;

public Xyz(int a,int b)

{

super(a);

j=b;

i = ++(super.i);

}

public void showAll()

{

System.out.println(“Superclass ‘i’ :: “+super.i);

System.out.println(“Subclass ‘i’ :: ” + i +” ‘j’ :: “+ j);

}

}

public class MultilevellnheritanceDemo

{

public static void main(String arg[])

{

Xyz ob = new Xyz(1,2);

ob.showAll();

} }

 

Output:.

 

Superclass ‘i’ :: 2

Subclass ‘i’ :: 2 ‘j’:: 2

 

In the above code, in subclass the data member of superclass ‘i’ hides with subclass data member ‘i’, so that using super keyword it access .

The class member attributes (fields) and methods are bounded with some accessibility modifier, which defines the access scope of the member. In this section, we’ll study how to access the data members (attributes) of the class.

 

All the public and protected members of the parent of subclass always inherit, doesn’t matter what package the subclass is in.

1. Just like any other fields of the subclass, the inherited fields can be used.
2. If you declare a field in the subclass, with the same name as in superclass, then the subclass field will hide the superclass inherited filed.
3. The inherited method can be used as same as the subclass method are used.
4. You can define a new instance method in the subclass, that has the same signature as one of the superclass method, called overriding.
5. You can define a new static method (class member) for the subclass, that has the same signature as one of the superclass method, called hiding.
6. The subclass constructor invokes the superclass constructor either implicitly if the superclass constructor is default or by using the keyword super.

 

The attributes can be with any access modifier like private, protected, public, and default. There is fixed scope of accessibility or extendibility of the attribute in subclass. The attributes will be inherited or not, it totally depends on its access modifier. There are four access modifiers as follows with its scope:

 

1. 1.private: never inherit
2. 2.protected: only in its subclass
3. 3. public : inherit
4. 4.default: inherit

 

Example:

 

//Create a superclass

 

class SuperClass

{

private int a;

protected int b;

public int c;

int d;

public void storeab()

{

a = 41;

b = 41;

c = 41;

d = 41;

}

public void showab()

{

 

System.out.println(“SuperClass contents :: a = “+a+” b “+b+” c “+c+” d = “+d);

}

}

 

//Create a sub class by extending class SuperClass

 

class SubClass extends SuperClass

{

int s;

public void sumab()

{

s=a+b+c+d;

s = b+c+d;

}

public void shows()

{

System.out.println(“SubClass contents:: s = “+s);

 

}

}

 

public class SingleInheritanceDemo

{

public static void main(String arg[])

{

SubClass ob = new SubClass();

ob.storeab();

ob.sumab ();

ob.showab ();

ob.shows();

} }

 

When you compile this code you’ll find the following message:

                          

But if you want the value of attribute ‘a’ in subclass then either implement a method that returns its value or define it as default or public. The modified version of the program is given below with definition of a method that returns the value of attribute ‘a’ of SuperClass.

 

//Create a superclass

 

class SuperClass

{

private int a;

protected int b;

public int c;

int d;

public void storeab()

{

a = 41;

b = 41;

c = 41;

d = 41;

}

public void showab()

{

 

System.out.println(“SuperClass contents :: a = “+a+” b “+b+” c “+c+” d = “+d);

}

 

public int geta()

{

return a;

}

}

 

//Create a sub class by extending class SuperClass

 

class SubClass extends SuperClass

{

int s;

public void sumab()

{

s=a+b+c+d;

s = b+c+d;

}

public void shows()

{

System.out.println(“SubClass contents:: s = “+s);

 

}

}

 

public class SingleInheritanceDemo

{

public static void main(String arg[])

{

SubClass ob = new SubClass();

ob.storeab();

ob.sumab ();

ob.showab ();

ob.shows();

} }

 

The protected, public and default field ‘b’, ‘c’ and ‘d’ are inherited in subclass .

 For the reusability of existing classes, inheritance came into use, and java supports only two types of inheritance, in which a class extends another class.

1. 1.Single Inheritance
2. 2.Multilevel Inheritance

 

In Java, a class can be derived from another class using the general form:

 

access_specifier class Subclass extends Superclass

{

//Derived class data and methods

}

 

Various types of inheritance are discussed in the section below.

 

Single Inheritance

 

In this type of inheritance, a single sub class is derived from a single base class.

                               

Multiple Inheritances

 

In multiple inheritances, there is more than one base class from which the child class is derived. This results in the duplication of data with the derived class. This is a major problem with OOP and a mechanism called Virtual Base Class is provided for this, in which, one of the base classes is made virtual to avoid the duplicate inheritance of data.

                                 

Java does not directly support multiple inheritances. This is because different classes may have different variables with same name that may be contradicted and can cause confusions in JVM, thus resulting in errors. Java only supports multiple inheritances when used with Interfaces. We can extend one class only to avoid ambiguity problem with JVM. In interface we have to define the functions. So there is no ambiguity. In C++, it is big problem but in JAVA this issue has been improved by introducing Interfaces.

 

Multilevel Inheritance

 

In multilevel inheritance, a class derives another class, and from the derived class, another sub class is derived.

                                              

Hybrid Inheritance

 

There may occur situations where we need to apply two or more types of inheritance in the design of a program. For such cases, hybrid inheritance is used.

                                             

Multiple inheritances cannot be possible by extending more than one class, it can be possible with one another and important features of the Java, called interface.

 

To inherit a class into another class extends keyword is used.

 

class subclassName extends superclassName

{

//body of subclass

}

 

The most important point in inheritance is that, the subclass object will be created and all the accessible members of superclass and its own are accessed by subclass object.

 

Example:

 

// Create a superclass

class SuperClass

{

int a,b;

public void storeab()

{

a = 41;

b = 41;

}

public void showab()

{

System.out.println(“SuperClass contents :: a = “+a+” b = “+b);

}

}

//Create a sub class by extending class SuperClass

class SubClass extends SuperClass

{

int s;

public void sumab ()

{

s=a+b;

}

public void shows()

{

System.out.println(“SubClass contents:: s = “+s) ;

}

}

public class SingleInheritance

{

public static void main(String arg[])

{

SubClass ob = new SubClass();

ob.storeab ();

ob.sumab();

ob.showab();

ob.shows();

}

}

 

Output:

                                  

In the give example, the object of the class SubClass, ob, is used to call the public member of it’s superclass as well as it’s own. So that we can observe, that the public member of SuperClass are inherited in the SubClass, i.e. become the part of it, so that using ob, we’re able to call them or access them. In the method sumab() of SubClass, we are directly using the a,b of SuperClass without using any instance of SuperClass, because these are inherited in the Subclass. The fields are without any access modifier, count under the category of default access modifier, and methods are defined as public.

Inheritance is one of the most dominant and vital feature of the object oriented programming because it supports the hierarchical classifications, reusability of class; and defined to specialization. Java is a language that supports inheritance but with some additional advantages and features. [Read more…] about What is Class Inheritance?