Java Implements Keyword

To understand about the keyword implements we need to learn about the concept of the interfaces and inheritance in java programming languages. So let us learn about the interface and inheritance in java.

a

Interface in Java

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.

Only abstract methods—not method bodies—are permitted in the Java interface. Multiple inheritance and abstraction are implemented using it in Java.

Use of java interface:

The major three justifications for using an interface. The list of them is below.

• To achieve abstraction, it is used.
• We can offer the functionality of multiple inheritance through an interface.
• Loose couplingor 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 given by; all methods in an interface are provided with an empty body, and all fields are by default public, static, and final. All the methods implemented in an interface that must be implemented by a class which implements the interface.

Syntax for declaring an interface:

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

Example of Java Interface:

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 []) {
Sketchableg=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 []) {
Sketchableh=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 ();
 }  
}