Interface in Java and Uses of Interface in Java

Abstraction is a process of hiding the implementation details and showing only functionality to the user. Earlier we have learnt about abstract class in java which is used to achieve partial abstraction. In this tutorial, we will discuss about interfaces which are used for achieving full abstraction. 

What is an Interface?

An interface is a blueprint of a class, it can have methods and variables like a class but methods declared in a interface will be by default abstract(only declaration no body) and the variables declared will be public, static & final by default.

Use of Interface in Java

• Using interface we can achieve 100% abstraction in Java, as the methods doesn’t have body and the class needs to implement them before they access it.
• Java does not support multiple inheritance using the interface we can achieve this as a class can implement more than one interface.

Example of Java Interface

interface Shape
{
        public abstract void size(); 
}
public class Logic implements Shape
{
    @Override
    public void size() 
    {
        System.out.println("Size method implementation called");
    }
    public static void main(String args[])
    {
        Logic l = new Logic();
        l.size();

        //Dynamic binding
        Shape s = new Logic();
        s.size();
    }
}

Output

Size method implementation called
Size method implementation called

In the above code we have an interface “Shape” which has a abstract method “size()” and Logic is the class which implements the size() method(provided body).

 Can Abstract Class have constructor?

Unlike Abstract class which can  have constructor,non abstract method , main method. Interface cannot have Constructor, non abstract method and main method.

public interface Shape
{
       public Shape()
       {
           System.out.println("Constructor not allowed in Interface");
       }
        public abstract void size(); 
        public void disp()
        {
            System.out.println("non-abstract method not allowed in Interface");
        }
        public static void main(String args[])
        {
           //Some Logic
        }
}

The above interface will throw compilation errors as the interface cannot have contructor,non-abstract method and main method(as public and abstract qualifiers are only permitted).

Important points to remember

• An Interface cannot be instantiated in Java.
• Methods declared in a interface should be public and abstract 
• Interface cannot have concrete methods(non-abstract methods or methods with body)
• variables declared should be public, static & final even though if you miss any one or all the qualifiers it will be automatically assigned. Lets see all the valid scenarios.

  interface Test
  {
  int a = 10;
  public int b = 10;
  static int c = 10;
  final int d = 10;
  static final int e =10;
  public static int f= 10;
  public final int g =10;
  }

• Interface variables must be initialized at the time of declaration else the compiler will throw error. Below is not a valid declaration

interface Test
{
int a;
}

• An Interface can only extend other interface (only one)
• A Class can implement any number of interface

interface Interface1
{
    public void method1();
}
interface Interface2 extends Interface1
{
    public void method2();
}
public class Demo implements Interface1,Interface2
{
    @Override
    public void method2() 
    {
    }
    @Override
    public void method1() 
    {
    }
    public static void main(String args[])
    {
    }
}

• If two interface have methods with same signature and same return type then the implementing class can implement any one of those.

interface Interface1
{
    public void method1();
}
interface Interface2 
{
    public void method1();
}
public class Demo implements Interface1,Interface2
{
    @Override
    public void method1() 
    {
    }
    public static void main(String args[])
    {
    }
}

• If two interface have methods with same signature and different return type cannot be implemented at the same time

interface Interface1
{
    public void method1();
}
interface Interface2 
{
    public int method1();
}
public class Demo implements Interface1,Interface2
{
    @Override
    public void method1() //will throw compilation error
    {
    }
    @Override
    public int method1() //will throw compilation error
    {
    }
    public static void main(String args[])
    {
    }
}

• In the implementing class we cannot change the variable value which is declared in the interface as it is final by default

interface Interface1
{
    int val=10;
    public void method1();
}

public class Demo implements Interface1
{
    @Override
    public void method1() 
    {
    }
    public static void main(String args[])
    {
        Interface1.val=20; //Will throw compilation error
    }
}