Interface
An interface is a reference type in java that means you can not create
an object of an interface like abstract class. You can only use
interface reference variable to hold the object of child class.
You can also say an interface is a blueprint of a class that means it tells a class what should it do? But not how should it do?
Suppose you want to open a bank in India. Then what is the first thing
that you have to do to open a bank? You have to take permission from
Reserve Bank Of India (RBI). RBI will tell you about all the basic
functionality that your bank should have like check balance, withdraw
money,transfer money etc.
But does not tell you about the implementation of those functionality.
Points to Remember:-
1. An interface can have only public and abstract methods. By default all the methods of an interface are public and abstract. (up to java 7)
2. You can not provide body of an abstract method.
2. You can not provide body of an abstract method.
3. An interface can have only static
constants. That means all the data member of an interface is public
static and final by default.
Need of An Interface:-
1. It is used to achieve the abstraction in java.
2. It is used to achieve the multiple inheritance in java.
Example:-
interface My { int a; // by default public static and final void show(); // by default public and abstract } class Temp implements My { public void show() { System.out.println("show method"); } }
If any class implements an interface then it must have to give
implementation of all the abstract methods of an interface otherwise it
will be a compilation error.
Multiple Inheritance in Java:-
java does not support multiple inheritance. But with the help of interfaces you can achieve multiple inheritance in java.
An interface can extends from any number of interfaces and a class can implements any number of interfaces.
Example:-
interface My { void show(); // by default public and abstract } interafce My1 { void show(); // by default public and abstract } interface Demo extends My,My1 { void display(); // by default public and abstract }
Class Implementing Multiple Interfaces:-
interface My { void show(); // by default public and abstract } interafce My1 { void show(); // by default public and abstract } class Temp implements My,My1 { void show() { System.out.println("show method"); } public static void main(String ar[]) { Temp t=new Temp(); t.show(); } }
Multiple Inheritance Is Not Supported With Classes. Why?
You can not achieve multiple inheritance with the help of classes in java. A class can not be extended from multiple classes.
This is because of ambiguity or diamond problem.
Lets Understand this With The Help Of An Example:-
I am assuming here that multiple inheritance is possible with the help
of classes in java. Then we will discuss about the problems that will
arise.
class Temp { void show() { System.out.println("show method from Temp class"); } } class Temp1 { void show() { System.out.println("show method from Temp1 class"); } } Class Demo extends Temp,Temp1 { // both the methods will be inherited /* void show() { System.out.println("show method from Temp class"); } */ /* void show() { System.out.println("show method from Temp1 class"); } */ public static void main(String ar[]) { Demo d=new Demo(); d.show(); // Error will be generated } }
As you can see in above example that the show() method of both Temp and
Temp1 will be inherited in Demo class. When we will call show() method
from Demo object then compiler will generate an error. Because both
methods are identical the compiler is confused and does not know which
method it has to call that is why it will generate an error which is ambiguity error.
Interface Inheritance:-
interface My { void show(); } interface My1 extends My { void display(); } class Temp implements My1 { public void show() { System.out.println("show method"); } public void display() { System.out.println("display method"); } public static void main(String ar[]) { Temp t=new Temp(); t.show(); t.display(); } }
Java 8 Features
There are two new features introduced in interfaces in java 8.
1. Default Methods
2. Static methods
Until java 7 you can not declare default and static method in your interface.
Default Methods:-
default is the keyword given by java to declare default methods
in an interface. Until java 7 you can not declare method with body
(non-abstract method) in an interface. But in java 8 you can have method
with body in your interface with the help of default keyword.
Example:-
interface My { default void show() { System.out.println("show method"); } } class Temp implements My { public static void main(String ar[]) { Temp t=new Temp(); t.show(); } }
Need Of Default Methods:-
Suppose you have created your software using java 6 version. Let you
have used an interface My in your software which is an built interface
of java in which there is 5 methods.
In java 7 version java wants to update that interface and wants to add 2
more methods in that interface. You have updated your java software to
java 7 version. In java 7 version there are 7 methods in My interface
but you have given body of only 5 methods in your software and your
software will give you an error and ask you to give body of remaining
two methods.
To solve this problem java has introduced default method
concept in java 8. So that java can add new features in the technology
and when you update your software you does not get any error also.
Note:- You cannot make default method as static.
Static Methods In Interface:-
Static methods are the utility methods in java that means these method
is shared by the all the objects of an class / interface. Static methods
are common for all the objects of a class.
You can also give body of a method with the help of static methods in
java. Untill java 7 you can not declare static methods in an interface.
Example:-
interface My { static int cube(int a) { return(a*a*a); } } class Temp implements My { public static void main(String ar[]) { int b=My.cube(5); System.out.println(b); } }
Note:- You can not declare a default method as static.
Java 9 Features
Private Method In Interface:-
You can declare private method in your interface from java 9 on wards.
Example:-
interface Demo { default void call() { fetchRecord(); } private void fetchRecord() { // fetching record from database } } class Test implements Demo { public static void main(String ag[]) { Test t=new Test(); t.call(); } }
Need Of Private Method:-
In the above program there is two methods in Demo interface. default method
call() will be inherited in Test class automatically. But inside call
method we have used fetchRecord() method which will fetch the record
from database whose code we do not want to expose in the child class.
There was no way to hide your internal code in interfaces before.
Private methods are introduced to hide your internal code in java 9.
