Java/J2EE and SOA (16 Blogs) Become a Certified Professional
AWS Global Infrastructure

Programming & Frameworks

Topics Covered
  • C Programming and Data Structures (16 Blogs)
  • Java/J2EE and SOA (16 Blogs)
  • Spring Framework (7 Blogs)
  • PHP and MySQL (6 Blogs)
SEE MORE

MI-new-launch

myMock Interview Service for Real Tech Jobs

myMock-widget-banner-bg

Everything You Need to Know about Java Interfaces

185 Views

MI-new-launch

myMock Interview Service for Real Tech Jobs

myMock-mobile-banner-bg

myMock Interview Service for Real Tech Jobs

  • Mock interview in latest tech domains i.e JAVA, AI, DEVOPS,etc
  • Get interviewed by leading tech experts
  • Real time assement report and video recording

Java Interface is an advanced level of achieving abstraction in the Java Programming Language. Java interface helps in the reduction of complexity in the code and simplifies the readability. In this article, I will explain to you Java Interface through the following docket.

 

What is a Java Interface?

Computer Interface is known as a boundary which separates two or more systems. It exchanges data between the components in a system which could signals, commands or protocols.

java-interface

Java Abstraction provides the functionality of a particular method by hiding the implementation logic written inside the method. Similarly, Java Interface is also an Abstract Class which includes the Method Declaration but not its definition. A class implements an Interface to inherit the abstract methods. Along with abstract methods, an interface can also include constants, static methods, nested interfaces and default methods.

image

 

 

Why we need an Interface?

Java does not support Multiple Inheritances, due to which, It will not allow classes to extend more than one class at an instance. Child classes could not inherit the properties of multiple parent classes at a single instance, as it results in Diamond Problem. To overcome this issue, Interface is introduced. Let us understand this problem through an example.

 

diamond-problrm

 

Let us assume we have two planes, one can carry only passengers, the other one only cargo. Now, we need to inherit the properties of both the cargo plane and the passenger plane. Java would not support this solution as it ends up in ambiguity between the two planes.

diamond

But, if you can make it possible by making Java feel that it is inheriting one plane and implementing the methods present in the other plane. It is like a commercial Airplane which takes both passengers and cargo luggage. The Interface is like making a bigger plane which could do both the tasks without interfering with the components of one another, instead just borrowing the methods from the Interface Class.

 

inheritance

 

 

//Class A Code

package multiple;
class A{
     void msg(){System.out.println("Hello");}
}

//Class B Code

package multiple;
class B{
     void msg(){System.out.println("Welcome");}
}

Class C Code

package multiple;
class C extends A,B{ // This will not be accepted by Java, It will throw an error and code will not be executed.
public static void main(String args[]){
        C obj=new C();
        obj.msg();
        }
}

Output:

Error. This particular approach throws an exception. Java do not support Multiple inheritances. This error is known as Diamond Problem

Let us ty a solution by using interface, Child Classes can access the methods from Multiple Parent classes at a single instance.

//Interface Code

package MIS;
public interface solution {
public void Hello();
public void Welcome();
}

//Class Code

package MIS;
public class classA implements solution {
       public void Hello() {
            java.lang.System.out.println("Hello world");
       }
       public void Welcome() {
            java.lang.System.out.println("Welcome to Edureka");
}
public static void main(String[] args) {
       classA Edureka = new classA();
       Edureka.Hello();
       Edureka.Welcome();
       }
}

Output:

Hello World
Welcome to Edureka

Declaring a Java Interface: Syntax

interface interface_name {
// declare constant fields;
// declare methods();
//  default methods;
}

 

Java Interface Example

Let us create a simple Calculator based on Java Interface.

calci

 

//Interface Code

package basicoperations;
public interface maths {
public void add();
public void sub();
public void mul();
public void div();
}

//Class Code

package basicoperations;
import java.util.Scanner;
public class student1 implements maths {
        @Override
         public void add() {
         Scanner kb = new Scanner(System.in);
         System.out.println("Enter any two integer values to perform addition");
         int a=kb.nextInt();
         int b=kb.nextInt();
         int s=a+b;
         System.out.println("Sum of "+a+" and "+b+" is "+s);
   }
        @Override
         public void sub() {
         Scanner kb = new Scanner(System.in);
         System.out.println("Enter any two integer values to perform substraction");
         int a=kb.nextInt();
         int b=kb.nextInt();
         int s=a-b;
         System.out.println("Difference of "+a+" and "+b+" is "+s);
  }
        @Override
         public void mul() {
         Scanner kb = new Scanner(System.in);
         System.out.println("Enter any two integer values multiplication");
         int a=kb.nextInt();
         int b=kb.nextInt();
         int s=a*b;
         System.out.println("Product of "+a+" and "+b+" is "+s);
  }
        @Override
         public void div() {
         Scanner kb = new Scanner(System.in);
         System.out.println("Enter any two integer values division");
         int a=kb.nextInt();
         int b=kb.nextInt();
         int s=a/b;
         System.out.println("Quotient of "+a+" and "+b+" is "+s);
  }
public static void main(String[] args) {
   student1 Edureka1 = new student1();
   Edureka1.add();
   Edureka1.sub();
   Edureka1.mul();
   Edureka1.div();
   }
}

Output:

 

mathematics-java-interface

 

 

Nesting the Java Interface

Interface Nesting is a process of declaring an Interface inside another Existing Interface or declaring an Interface inside a Class. The Nested Interface is also known as an Inner Interface.

The Nested Interface cannot be accessed directly. Hence, Nesting is implemented in order to resolve the Namespaces by grouping them with their related Interfaces and Classes. By this procedure, we can call the Nested Interface through the Outer Class or Outer Interface name followed by a dot( . ), and Interface name.

Let us try some examples based on Interface Nesting. First, let us try to nest a Java Interface inside another Java Interface as shown below:

//Interface Code

package Nest;
public interface OuterInterface {
     void display();
     interface InnerInterface{
           void InnerMethod();
       }
}

//Class Code

package Nest;
class NestedInterfaceDemo
implements OuterInterface.InnerInterface{
public void InnerMethod(){
   int n = 10, t1 = 0, t2 = 1;
   System.out.print("First " + n + " terms: ");
         for (int i = 1; i <= n; ++i)
        {
             System.out.print(t1 + " + ");
             int sum = t1 + t2;
             t1 = t2;
             t2 = sum;
        }
        System.out.println("nPrinting from Nested InnerInterface method...!n");
    }
public static void main(String args[]){
       OuterInterface.InnerInterface obj=new NestedInterfaceDemo();
       obj.InnerMethod();
    }
}

Output:

First 10 terms: 0 + 1 + 1 + 2 + 3 + 5 + 8 + 13 + 21 + 34 +
Printing from Nested InnerInterface method...!

 

Now, Let us try to nest a Java Interface inside a Java Class.

//Interface Code

package Nest2;
public class EdurekaClass {
       interface EdurekaInterface{
              void NestedMethod();
        }
}

//Class Code

package Nest2;
class NestedInterfaceDemo2 implements EdurekaClass.EdurekaInterface{
public void NestedMethod(){
            String input = "Edureka";
            byte [] strAsByteArray = input.getBytes();
            byte [] result = new byte [strAsByteArray.length];
            for (int i = 0; i<strAsByteArray.length; i++)
                    result[i] = strAsByteArray[strAsByteArray.length-i-1];
                    System.out.println(new String(result));
            }
public static void main(String args[]){
          EdurekaClass.EdurekaInterface obj = new NestedInterfaceDemo2();
          obj.NestedMethod();
     }
}

Output:

akerudE

Although an Interface looks almost similar to a Class, there are some differences between them, Let us discuss their differences.

 

Difference between Java Class and Java Interface

 

INTERFACECLASS
Supports Multiple InheritanceDoes not support Multiple Inheritance
Does not have Data MembersIncludes Data Members
Does not have ConstructorsIncludes Constructors
Includes Inclomplete Members(Signature Member)Includes both Complete(Abstract) and Incomplete members
Does not have Access ModifiersIncludes Access Modifiers
The interface does not have Static MembersThe class has all its members as Static

 

 

Advantages and Disadvantages of Java Interface

Advantages:

  • Java Interface supports Multiple Inheritance.
  • Java Interface enables programmers to break up the complex programming approaches and simplify the dependencies between the objects.
  • Java Interface makes the data members and methods in an application to be loosely coupled.

Disadvantages:

  • Use of Java Interface brings down the execution speed of the application.
  • Java Interfaces in the application are either used repeatedly at large extent or hardly used at all.

 

Key Points on Java Interface

  • None of the methods declared in the interface has a body which makes it provide complete abstraction.
  • It is not possible to create an object of an interface. Hence, the Instantiation of an Interface is not possible.
  • A Class can implement an interface by using the keyword implements. Let us see this through an example.

//Interface Code

package extInterface;
public interface extInterface {
        public void method1();
        public void method2();
}

//Class Code

package extInterface;
import java.util.Scanner;
class Edureka implements extInterface{
    public void method1(){
         System.out.println("implementation of method1");
         Scanner scanner = new Scanner(System.in);
         System.out.println("Enter number to find square root in Java : ");
         double square = scanner.nextDouble();
         double squareRoot = Math.sqrt(square);
         System.out.printf("Square root of number: %f is : %f %n" , square, squareRoot);
    }
    public void method2(){
               System.out.println("implementation of method2");
        }
public static void main(String arg[]){
               extInterface obj = new Edureka();
               obj.method1();
       }
}

Output:

implementation of method1
Enter number to find square root in Java :
16
Square root of number: 16.0 is : 4.0
  • A Class can implement multiple inheritances at a single instance. Let us understand it through the following code.

//Interface 1 Code

package ExtendInt;
public interface Interface1 {
       public void armstrong();
}

//Interface 2 Code

package ExtendInt;
public interface Interface2 {
           public void prime();
}
//Class Code
package ExtendInt;
public class Edureka2 implements Interface1,Interface2{
          public void armstrong(){
                 int c=0,a,temp;
                 int n=153;// input 
                 temp=n;
                 while(n>0){
                        a=n%10;
                        n=n/10;
                        c=c+(a*a*a);
                 }
                  if(temp==c)
                          System.out.println("armstrong number");
                  else
                          System.out.println("Not armstrong number");
                          System.out.println("Extending to Interface 1");
          }
          public void prime(){
          int i,m=0,flag=0;
          int n=3;// input 
          m=n/2;
          if(n==0||n==1){
                  System.out.println(n+" is not prime number");
          }
          else{
                  for(i=2;i<=m;i++){
                        if(n%i==0){
                                System.out.println(n+" is not prime number");
                                flag=1;
                                break;
                        }
                  }
                  if(flag==0) { 
                  System.out.println(n+" is prime number"); 
                  }
          }
          System.out.println("Extending to Interface 2");
          }
public static void main(String args[]){
               Interface2 obj = new Edureka2();
               obj.prime();
               Interface1 obj1 = new Edureka2();
               obj1.armstrong();
         }
}

Output:

3 is prime number
Extending to Interface 2
armstrong number
Extending to Interface 1

 

  • Java Interface requires the variables declared to be initialized at the time of declaration.
  • Access Modifiers for an interface are set to public static and final by default. Let us understand this by an example

//Interface Code

package test;
public interface Try {
       //public int a=10;
       //public static final int a=10;
       //static int a=0;
       //final int a=10;
       //int a=10;
}
  • All the above declarations are true and valid inside an Interface.
  • Java Interface is capable to extend any number of Interfaces, but can never implement one.
  • A Java Class can implement any number of Interfaces.
  • Java Class cannot implement Interfaces with the same method name and different return type.
  • If there are two or more methods with the same method name, are existing in multiple interfaces, then implementing the method for once is enough. Let us understand this with a practical example.

//Interface Code

package same;
public interface A {
        public void display();
}
//Interface Code
package same;
public interface B {
        public void display();
}
//Class Code
package same;
class same implements A,B {
           public void display() {
                   System.out.println("displaying data");
           }
     public static void main(String[] args) {
           same print = new same();
           print.display();
     }
}

Output:

Welcome to Edureka E-Learning

With this, we come to an end of this article. I hope you have understood the importance of Interface, Syntax, functionality, Interface Nesting, Key points of Java Interface and operations performed using them.

Now that you have understood basics of Java, check out the Java training by Edureka, a trusted online learning company with a network of more than 250,000 satisfied learners spread across the globe. Edureka’s Java J2EE and SOA training and certification course is designed for students and professionals who want to be a Java Developer. The course is designed to give you a head start into Java programming and train you for both core and advanced Java concepts along with various Java frameworks like Hibernate & Spring.

Got a question for us? Mention it in the comments section of this “Java Interface” blog and we will get back to you as soon as possible.

Comments
0 Comments

Browse Categories

Subscribe to our Newsletter, and get personalized recommendations.