Java Interface

Try it on GfG Practice

An Interface in Java programming language is defined as an abstract type used to specify the behaviour of a class. An interface in Java is a blueprint of a behaviour. A Java interface contains static constants and abstract methods.

Key Properties of Interface:

• The interface in Java is a mechanism to achieve abstraction.
• By default, variables in an interface are public, static, and final.
• It is used to achieve abstraction and multiple inheritance in Java.
• It supports loose coupling (classes depend on behavior, not implementation).
• In other words, interfaces primarily define methods that other classes must implement.
• An interface in Java defines a set of behaviours that a class can implement, usually representing an IS-A relationship, but not always in every scenario.

Example: This example demonstrates how an interface in Java defines constants and abstract methods, which are implemented by a class.

//Driver Code Starts
import java.io.*;

// Interface Declared
//Driver Code Ends

interface testInterface {
  
    // public, static and final
    final int a = 10;

    // public and abstract
    void display();
}

// Class implementing interface
class TestClass implements testInterface {
  
    // Implementing the capabilities of
    // Interface
    public void display(){ 
      System.out.println("Geek"); 
    }
}

class Geeks

//Driver Code Starts
{
    public static void main(String[] args)
    {
        TestClass t = new TestClass();
        t.display();
        System.out.println(t.a);
    }

}
//Driver Code Ends

Geek
10

Note: In Java, the abstract keyword applies only to classes and methods, indicating that they cannot be instantiated directly and must be implemented. When we decide on a type of entity by its behaviour and not via attribute we should define it as an interface.

Syntax:

nterface InterfaceName {

// Constant fields (public static final by default)

int CONSTANT = 10;

// Abstract method (public abstract by default)

void methodName();

// Default method (JDK 8+)

default void defaultMethod() {

System.out.println("Default implementation");

}

// Static method (JDK 8+)

static void staticMethod() {

System.out.println("Static method in interface");

}

// Private method (JDK 9+)

private void privateMethod() {

System.out.println("Private helper method");

}

}

Note:

• Private methods can only be called inside default or static methods in the interface, not by implementing classes
• Static methods are also accessible via the3interface itself not through objects

To declare an interface, use the interface keyword. It is used to provide total abstraction. That means all the methods in an interface are declared with an empty body and are public and all fields are public, static, and final by default. A class that implements an interface must implement all the methods declared in the interface. To implement the interface, use the implements keyword.

Relationship Between Class and Interface

A class can extend another class, and similarly, an interface can extend another interface. However, only a class can implement an interface, and the reverse (an interface implementing a class) is not allowed.

Difference Between Class and Interface

Although Class and Interface seem the same there are certain differences between Classes and Interface. The major differences between a class and an interface are mentioned below:

When to Use Class and Interface?

• Use a Class when:
  • Use a class when you need to represent a real-world entity with attributes (fields) and behaviors (methods).
  • Use a class when you need to create objects that hold state and perform actions
  • Classes are used for defining templates for objects with specific functionality and properties.
• Use a Interface when:
  • Use an interface when you need to define a contract for behavior that multiple classes can implement.
  • Interface is ideal for achieving abstraction and multiple inheritance.

Implementation: To implement an interface, we use the keyword implements

Let’s consider the example of Vehicles like bicycles, cars, and bikes share common functionalities, which can be defined in an interface, allowing each class (e.g., Bicycle, Car, Bike) to implement them in its own way. This approach ensures code reusability, scalability, and consistency across different vehicle types.

Example: This example demonstrates how an interface can be used to define common behavior for different classes (Bicycle and Bike) that implement the interface.

import java.io.*;

interface Vehicle {
    
    // Abstract methods defined
    void changeGear(int a);
    void speedUp(int a);
    void applyBrakes(int a);
}

// Class implementing vehicle interface
class Bicycle implements Vehicle{
    
    int speed;
    int gear;
    
    // Change gear
    @Override
    public void changeGear(int newGear){
        gear = newGear;
    }
    
    // Increase speed
    @Override
    public void speedUp(int increment){
        speed = speed + increment;
    }
    
    // Decrease speed
    @Override
    public void applyBrakes(int decrement){
        speed = speed - decrement;
    }
    
    public void printStates() {
        System.out.println("speed: " + speed
            + " gear: " + gear);
    }
}

// Class implementing vehicle interface
class Bike implements Vehicle {
    
    int speed;
    int gear;
    
    // Change gear
    @Override
    public void changeGear(int newGear){
        gear = newGear;
    }
    
    // Increase speed
    @Override
    public void speedUp(int increment){
        speed = speed + increment;
    }
    
    // Decrease speed
    @Override
    public void applyBrakes(int decrement){
        speed = speed - decrement;
    }
    
    public void printStates() {
        System.out.println("speed: " + speed
            + " gear: " + gear);
    }
    
}

class Main
{    
    public static void main (String[] args) 
    {
    
        // Instance of Bicycle(Object)
        Bicycle bicycle = new Bicycle();
        
      	bicycle.changeGear(2);
        bicycle.speedUp(3);
        bicycle.applyBrakes(1);
        
        System.out.print("Bicycle present state : ");
        bicycle.printStates();
        
        // Instance of Bike (Object)
        Bike bike = new Bike();
        bike.changeGear(1);
        bike.speedUp(4);
        bike.applyBrakes(3);
        
        System.out.print("Bike present state : ");
        bike.printStates();
    }
}

Bicycle present state : speed: 2 gear: 2
Bike present state : speed: 1 gear: 1

Multiple Inheritance in Java Using Interface

Multiple Inheritance is an OOPs concept that can't be implemented in Java using classes. But we can use multiple inheritances in Java using Interface. Let us check this with an example.

Example: This example demonstrates how a class can implement multiple interfaces (Add and Sub) to provide functionality for both addition and subtraction operations.

import java.io.*;

// Add interface
interface Add{
    int add(int a,int b);
}

// Sub interface
interface Sub{
  	int sub(int a,int b);
}

// Calculator class implementing
// Add and Sub 
class Cal implements Add , Sub
{
  	// Method to add two numbers
  	public int add(int a,int b){
      	return a+b;
    }
  
  	// Method to sub two numbers
  	public int sub(int a,int b){
    	return a-b;
    }
  
}

class GFG{
    // Main Method
    public static void main (String[] args) 
    {
      	// instance of Cal class
      	Cal x = new Cal();
      
      	System.out.println("Addition : " + x.add(2,1));
      	System.out.println("Substraction : " + x.sub(2,1));
      
    }
}

Addition : 3
Substraction : 1

New Features Added in Interfaces in JDK 8

There are certain features added to Interfaces in JDK 8 update mentioned below:

1. Default Methods

• Interfaces can define methods with default implementations.
• Useful for adding new methods to interfaces without breaking existing implementations.

Example: This example demonstrates the use of default methods in interfaces (introduced in JDK 8) to provide a method implementation within the interface itself.

// interfaces can have methods from JDK 1.8 onwards
interface TestInterface
{
    final int a = 10;
    
  	default void display() {
        System.out.println("hello");
    }
}

// A class that implements the interface.
class TestClass implements TestInterface
{
    // Driver Code
  	public static void main (String[] args) {
        TestClass t = new TestClass();
        t.display();
    }
}

hello

2. Static Methods

• Interfaces can now include static methods.
• These methods are called directly using the interface name and are not inherited by implementing classes.

Another feature that was added in JDK 8 is that we can now define static methods in interfaces that can be called independently without an object. These methods are not inherited.

Example: This example demonstrates the use of static methods in interfaces (introduced in JDK 8), which can be called directly using the interface name without needing an instance.

interface TestInterface
{
    final int a = 10;
    static void display()
    {
        System.out.println("hello");
    }
}

// A class that implements the interface.
class TestClass implements TestInterface
{
    // Driver Code
    public static void main (String[] args)
    {
        TestInterface.display();
    }
}

hello

3. Private Methods

• Interface can now include private methods.
• Private methods are defined within the interface but it cannot be accessed by the implementing classes.
• Private methods cannot be overridden by implementing classes as they are not inherited.

Example: This example demonstrates the use of private methods in interfaces (introduced in JDK 8) that can be called by default methods within the same interface but are not accessible outside the interface.

interface Vehicle {
    // Private method for internal use
    private void startEngine() {
        System.out.println("Engine started.");
    }
    
    // Default method that uses the private method
    default void drive() {
         // Calls the private method
        startEngine(); 
        System.out.println("Vehicle is now driving.");
    }
}

class Car implements Vehicle {
    // Car class implements Vehicle interface and inherits the default method 'drive'
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        // This will call the default method, which in turn calls the private method
        car.drive();  
    }
}

Engine started.
Vehicle is now driving.

4. Functional Interface

• Functional interfaces can be used with lambda expressions or method references.
• The @FunctionalInterface annotation can be used to indicate that an interface is a functional interface, although it’s optional.

Example: This example demonstrates the use of a functional interface in Java, which contains exactly one abstract method and can be used with lambda expressions or method references.

@FunctionalInterface
interface MyFunctionalInterface {
    void singleAbstractMethod();
}

Extending Interfaces

One interface can inherit another by the use of keyword extends. When a class implements an interface that inherits another interface, it must provide an implementation for all methods required by the interface inheritance chain.

Example: This example demonstrates how interface inheritance works in Java, where one interface (B) extends another (A), and a class (GFG) implements all the methods from both interfaces.

interface A {
    void method1();
    void method2();
}

// B now includes method1
// and method2
interface B extends A {
    void method3();
}

// the class must implement
// all method of A and B.
class GFG implements B 
{
    public void method1() {
        System.out.println("Method 1");
    }
  
    public void method2() {
        System.out.println("Method 2");
    }
  
    public void method3() {
        System.out.println("Method 3");
    }
  
  	public static void main(String[] args){
      	
      	// Instance of GFG class created
      	GFG x = new GFG();
      	
      	// All Methods Called
      	x.method1();
      	x.method2();
      	x.method3();
    }
}

Method 1
Method 2
Method 3

In a Simple way, the interface contains multiple abstract methods, so write the implementation in implementation classes. If the implementation is unable to provide an implementation of all abstract methods, then declare the implementation class with an abstract modifier, and complete the remaining method implementation in the next created child classes. It is possible to declare multiple child classes but at final we have completed the implementation of all abstract methods.

In general, the development process is step by step:

Level 1 - interfaces: It contains the service details.
Level 2 - abstract classes: It contains partial implementation.
Level 3 - implementation classes: It contains all implementations.
Level 4 - Final Code / Main Method: It have access of all interfaces data.

Example: This example demonstrates level-wise implementation of interfaces and abstract classes, where each level adds more functionality, and the final class provides full implementation of all abstract methods.

// implementation Level wise
import java.io.*;
import java.lang.*;
import java.util.*;

// Level 1
interface Bank {
    void deposit();
    void withdraw();
    void loan();
    void account();
}

// Level 2
abstract class Dev1 implements Bank {
    public void deposit()
    {
        System.out.println("Your deposit Amount :" + 100);
    }
}

abstract class Dev2 extends Dev1 {
    public void withdraw()
    {
        System.out.println("Your withdraw Amount :" + 50);
    }
}

// Level 3
class Dev3 extends Dev2 {
    public void loan() {}
    public void account() {}
}

// Level 4
class Main 
{
    public static void main(String[] args)
    {
        Dev3 d = new Dev3();
        d.account();
        d.loan();
        d.deposit();
        d.withdraw();
    }
}

Your deposit Amount :100
Your withdraw Amount :50

Advantages of Interfaces

• Without bothering about the implementation part, we can achieve the security of the implementation.
• In Java, multiple inheritances are not allowed, however, you can use an interface to make use of it as you can implement more than one interface.

New Features Added in Interfaces in JDK 9

From Java 9 onwards, interfaces can contain the following also:

1. Static methods
2. Private methods
3. Private Static methods

Important Points:

In the article, we learn certain important points about interfaces as mentioned below:

• We can’t create an instance (interface can’t be instantiated) of the interface but we can make the reference of it that refers to the Object of its implementing class.
• A class can implement more than one interface.
• An interface can extend to another interface or interface (more than one interface).
• A class that implements the interface must implement all the methods in the interface.
• All the methods are public and abstract. All the fields are public, static, and final.
• It is used to achieve multiple inheritances.
• It is used to achieve loose coupling.
• Inside the Interface not possible to declare instance variables because by default variables are public static final.
• Inside the Interface, constructors are not allowed.
• From JDK 8, interfaces can have a main method for execution
• Interfaces can declare static, final, and private methods starting from JDK 8 and JDK 9.