Interface in Java

What is an Interface in Java?

An interface in the Java programming language is an abstract type that is used to specify a behavior that classes must implement. ... Interfaces cannot be instantiated, but rather are implemented. A class that implements an interface must implement all of the methods described in the interface, or be an abstract class. For example, we might have defined the following interface for classes that have a position.

public interface Locatable {
     public double getX();
     public double getY();
 }
 

With the interface defined, we will now need classes that claim to implement the interface. For this, we need to say so up front using an implements clause.

public class Ball implements Locatable { //...
 public class Paddle extends Block implements Locatable { //...
 

Any class that has such an implements clause has to define all of the methods defined in the interface. Otherwise, there's a compiler error. Thus, both Ball and Paddle must have getX and getY methods; since the interface says these methods take no parameters and return a double, they need to be defined this way in Ball and Paddle too. What makes interfaces useful is that they are types, too. The following would be completely legitimate.

Locatable loc = new Ball();
 System.out.println(loc.getX() + ", " + loc.getY());
 loc = new Paddle();
 System.out.println(loc.getX() + ", " + loc.getY());
 

You cannot create an instance of an interface: new Locatable() would be illegal. In some sense, with interfaces a class have two superclasses. Only one of these can be a true Java class, but the type conversion behavior makes it feel as if both the actual parent class and the implemented interface are superclasses.

Rules of Using Interface

• Methods inside Interface must not be static, final, native or strictfp.
• All variables declared inside interface are implicitly public static final variables(constants).
• All methods declared inside Java Interfaces are implicitly public and abstract, even if you don't use public or abstract keyword.
• Interface can extend one or more other interface.
• Interface cannot implement a class.
• Interface can be nested inside another interface.

Interface implementation

To declare a class that implements an interface, you include an implements clause in the class declaration. Your class can implement more than one interface, so the implements keyword is followed by a comma-separated list of the interfaces implemented by the class. By convention, the implements clause follows the extends clause, if there is one.

Example of Interface implementation

interface Moveable 
{
 int AVG-SPEED = 40;
 void move();
}

class Vehicle implements Moveable 
{
 public void move()
 {
  System .out. print in ("Average speed is"+AVG-SPEED");
 }
 public static void main (String[] arg)
 {
  Vehicle vc = new Vehicle();
  vc.move();
 }
}

Difference between an interface and an abstract class?

For Indepth understanding of Java Click on

Java Virtual Machines