Java Interface Keyword

An interface is also known as the blueprint in Java. It has constants of static values and methods of abstraction. The interface is a mechanism used by Java to declare or implement abstraction.

Multiple inheritance and abstraction are implemented using it in Java.

Use of java interface:

Below are the major justifications for using an interface.

• To achieve abstraction, it is used.
• Loose coupling or retriving is done by java interface, it can be employed.

Declaring an Interface

The interface is a keyword used to implement an interface using implementations. Total abstraction is achieved by all interface methods having an empty body and all fields being public, static, and final by default. Every one of the methods that must be implemented by a class that implements an interface.

Syntax for declaring an interface:

interface <interface_name> {     
    // initializing methods that abstract and declaring constants field    
}  

Examples of Java Interface

Example 1: Here the executable or printed interface has only a single method, and its implementation is provided in the S9 class that is given below.

interface executable {  
void print ();
}  
class S9 implements executable {  
public void print ()
 {
System.out.println("Raju bai");
}  


public static void main (String s []) {  
S9 bj = new S9();
bj.print ();
 }  
}  

Output of the program is given below:

Raju bai

Example 2: Sketchable

The Sketchable interface in this illustration has just one method. Rectangle and Circle classes are responsible for its implementation. In a real-world scenario, someone else defines the interface, but multiple implementation providers implement it. Furthermore, someone else uses it. The user of the interface is unaware of the implementation portion.

//Interface declaration: by first user  
interface Sketchable {  
void sketch ();
} 
//Implementation: by second user  
class Triangle implements {Sketchable
public void sketch ()
{
System.out.println("drawing triangle");}  
}  
class Square implements Sketchable {  
public void sketch () {System.out.println("drawing square");}  
}  
//Using interface: by third user  
class Test_ Interface 1{  
public static void main (String s []) {  
Sketchable g=new Square () ;//In real scenario, object is provided by method e.g. getSketchable ()  
g. sketch ();
}}  

Output of the program is:

drawing square 

Example 3: Bank

Let's look at yet another Java interface sample that implements the Bank interface

interface Bank {  
float Interestrate ();
}  
class uni implements Bank {  
public float Interestrate () 
{
return 9.15f;}  
}  
class inp implements Bank {  
public float Interestrate ()
{
return 9.7f;}  
}  
class Test_Interface_2{  
public static void main (String [] s) {  
Bank p=new uni ();
System.out.println("ROI: "+p. Interestrate ());
}}  

Output of the program is:

ROI: 9.15

Multiple Inheritance in Java

Multiple inheritance is the process or method of a class implementing more than one interface or an interface extending more than one interface.

Program:

interface executable {  
void print ();
}  
interface Showable {  
void show ();
}  
class D9 implements executable, Showable {  
public void print () {System.out.println("Hiiii");}  
public void show () {System.out.println("Raju");}  


public static void main (String s []) {  
 D9 obj = new D9();
obj.print ();
obj. show ();
 }  
}  

Output of the program is:

Hiiii
Raju

Interface Inheritance

An interface is implemented by a class, but one interface extends another.

interface Executable {  
void Exe ();
}  
interface Showable extends Executable {  
void show ();
}  
class Test_Interface_4 implements Showable {  
public void print () {System.out.println("Hiii");}  
public void show () {System.out.println("Raju bai");}  


public static void main (String s []) {  
Test_Interface_4 bj = new Test_Interface_4().  
bj. Exe ();
bj. show ();
 }  
}  

Output of the program is:

Hiii
Raju bai

Default Method in Interface Example

interface Sketchable {  
void sketch ();
default void msg () {System.out.println(" method is default");}  
}  
class Square implements Sketchable {  
public void sketch () {System.out.println("drawing square");}  
}  
class Test_Interface_Default {  
public static void main (String s []) {  
Sketchable h=new Square ();
h. Sketch ();
h.msg ();
}}  

Output of the program is:

drawing Square
 method is default

Nested Interface in Java

An interface is implemented by a class, but one interface extends another.

interface executable {  
 void print ();
 interface Messageexecutable {  
   void msg ();
 }  
}