BIG
DATA

JAVA

INTERFACE IN JAVA WITH EXAMPLES

Read more about »
  • Java 9 features
  • Read about Hadoop
  • Read about Storm
  • Read about Storm
 

Quick Links within the page



In OOP, Objects interact with the outside world through the methods that they expose. Methods form the object's interface with the outside world; the buttons on the front of your mobile phone, for example, are the interface between you and the electronic circuit on the other side of its plastic casing. You press the "call" button to connect to your loved ones.

An interface is a programming structure that enforce certain properties on an object (class). For example, say we have a car class and a scooter class and a truck class. Each of these three classes should have a start_engine() action. How the "engine is started" for each vehicle is left to each particular class, but the fact that they must have a start_engine action is the domain of the interface.

In its most common form, an interface is a group of related methods with empty bodies.A car's behavior, if specified as an interfacce, might appear as follows:

public interface Car {
	void startEngine();
    void accelerate();
    void applyBrakes();
}

Note that the method signatures have no braces and are terminated with a semicolon.A class implementing this interface looks like this:

public class BMW implements Car {
	
	//The compiler will now require that methods
	//startEngine, accelerate, applyBrakes
	//all be implemented. Compilation will fail if those
	//methods are missing from this class.

	public void startEngine() {
	
	}	
	public void accelerate() {
		
	}
	public void applyBrakes() {
		
	}
}

Interfaces form a contract between the class and the outside world, and this contract is enforced at build time by the compiler. If your class claims to implement an interface, all methods defined by that interface must appear in its source code before the class will successfully compile.

An interface is a collection of abstract methods. A class implements an interface, thereby inheriting the abstract methods of the interface.



Defining an Interface

An interface declaration consists of modifiers, the keyword interface, the interface name, a comma-separated list of parent interfaces (if any), and the interface body. For example:

public interface Car extends vehicle1, vehicle2 {
	void startEngine();
    void accelerate();
    void applyBrakes();
}

The public access specifier indicates that the interface can be used by any class in any package.An interface can extend other interfaces, just as a class.However, whereas a class can extend only one other class, an interface can extend any number of interfaces.

The Interface Body

The interface body can contain abstract methods, default methods, and static methods. An abstract method within an interface is followed by a semicolon, but no braces (an abstract method does not contain an implementation). Default methods are defined with the default modifier, and static methods with the static keyword. All abstract, default, and static methods in an interface are implicitly public, so you can omit the public modifier.

In addition, an interface can contain constant declarations. All constant values defined in an interface are implicitly public, static, and final. Once again, you can omit these modifiers.

Implementing an Interface

To get the best out of interface, you have to implement interface to class.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.

A class that implements an interface must implement all the methods declared in the interface. The methods must have the exact same signature as declared in the interface. The class need not implement the variables of an interface.

public interface Car {
	void startEngine();
    void accelerate();
    void applyBrakes();
}
public class BMW implements Car {
	public void startEngine() {
	
	}	
	public void accelerate() {
		
	}
	public void applyBrakes() {
		
	}
}
Implementing Multiple Interfaces

Yes, class can implement multiple interface unlike base classes.In this case, class have to implement all the methods declared in all the interfaces implemented.

public interface Car {
	void startEngine();
    void accelerate();
    void applyBrakes();
}
public interface ManualCar {
    void changeGear();
}
public class BMW implements Car, ManualCar{
	public void startEngine() {
	
	}	
	public void accelerate() {
		
	}
	public void applyBrakes() {
		
	}	
	public void changeGear() {
		
	}
}

Class BMW implements 2 interfaces called Car and ManualCar and implements all the methods declared in Car and ManualCar interfaces.

you will have to import the interface if the interfaces are not located in the same packages as the implementing class. Interfaces are imported just like classes.

Nested Interface

Interface declared within an interface or class is known as Nested Interface. Nested interface cannot be accessed directly, they must be referred by the outer interface or class

interface interface_A{  
	//some code
 interface nested_interface_B{  
	//some code
 }  
}


Interfaces and Inheritance

Just like classes can inherit, interface too can inherit from other interfaces.

public interface ParentInterface {
    public void display();
}

public interface ChildInterface extends ParentInterface {
    public void doWrok();
}

Now any class implementing ChildInterface has to implement all methods declared in ChildInterface as well as ParentInterface.

public class Demo implements ChildInterface {
    public void display()
	{
		//some code
	}
	
	public void doWrok()
	{
		//some code
	}
}

But unlike classes, interfaces can inherit from multiple interfaces. You can specify that by listing all interfaces to inherit from, separated by comma. A class implementing an interface which inherits from multiple interfaces must implement all methods from the interface and its parent interfaces.

public interface GrandParentInterface {
    public void getInfo();
}

public interface ParentInterface {
    public void display();
}

public interface ChildInterface extends ParentInterface, GrandParentInterface {
    public void doWrok();
}

[Note]:When implementing multiple interfaces, certainly there are no rules for how you handle the case when multiple interfaces have methods with the same signature that is same name and parameters.



Interfaces and Polymorphism

Interfaces provide a way to achieve polumorphism in Java. Here polymorphism means an object can be used as if it were of different types.

interface Vehicle {
	void applyBrakes();	
}

class Car implements Vehicle {
	public void applyBrakes() {
		System.out.println("Car applied brakes");
	}
}

class Bike implements Vehicle {
	public void applyBrakes() {
		System.out.println("Bike applied brakes");
	}	
}
class Demo {	
	public void Test() {	
		Vehicle vehicle1 = new Car();
		Vehicle vehicle2 = new Bike();
		
		vehicle1.applyBrakes();
		vehicle2.applyBrakes();
	}
}

Output:

Car applied brakes
Bike applied brakes

Still not convinced? Lets change the code of Demo class a bit so that it becomes evident.

class Demo {	
	public void Test() {
		List<Vehicle> list = new ArrayList<Vehicle>();	//this is also way of polymorphism
		list.add(new Car());
		list.add(new Bike());
		
		for(Vehicle myVehicle:list)
		{
			myVehicle.applyBrakes();
		}
	}
}

Output:

Car applied brakes
Bike applied brakes

Now you see, the code looks so much cleaner, thats polymorphism for you.



Marker interface

A interface with no field nor methods is called as Marker interface or Tag interface. in Java some examples of tag interfaces are: Serializable, Clonnable, EventListener etc.

You will be thinking, why define an interface with no methods? Since no methods marker interface can never define behavior. But marker interface caries type information which can be used to solve some problem.

Marker interface are used to indicate or signal something to compiler or JVM. For example, Serializable. If JVM sees a any class with Serializable interface, it does some special operation on it.

By answering like this, interviewer may ask "Why this indication or signalling cannot be done in other ways?". Answer is YES can be done by using some flags inside a class or much better option for Java 1.5 onwards is annotations.

public interface Serializable{  
}

[Note]:A marker annotation can serve the same purpose as a marker Interface, that is to 'mark' a class for something. But, if you use a marker interface then you have the benefit of compile time type checking. But annotations have lot many other benefits than marker interface.

Conclusion: marker interface in Java is used to indicate something to compiler, JVM but Annotation does better job.



Multiple inheritance in Java using interfaces

Multiple inheritance is a feature of some object-oriented computer programming languages in which an object or class can inherit characteristics and features from more than one parent object or parent class. Unlike some other popular object oriented programming languages like C++, java doesn't provide support for multiple inheritance in classes. Java doesn't support multiple inheritance in classes because it can lead to diamond problem as discuessed in previous chapter and rather than providing some complex way to solve it, there are better ways through which we can achieve the same result as multiple inheritance, that is using interfaces.

interface A
{
   public void myMethod();
}
interface B
{
   public void myMethod();
}
class C implements A, B
{
   public void myMethod()
   {
       System.out.println(" Multiple inheritance using interfaces");
   }
}

In the above code, class 'C' implemented two interfaces 'A' and 'B'. A class can implement mulitple interfaces. In the above case there is no ambiguity even though both the interfaces are having same method. That is because methods in an interface are always abstract by default, which are meant to be implemented in concrete implemented class.

Why multiple inheritance is allowed through interface and not by classes

Difference between classes and interfaces is that classes can have fields whereas interfaces cannot.In addition, you can instantiate a class to create an object, which you cannot do with interfaces.An object stores its state in fields, which are defined in classes.Now if you inherit or extend more than one class and you create an object of that class, that object will inherit fields from all of the class's superclasses.What if methods or constructors from different superclasses instantiate the same field? Which method or constructor will take precedence? That is why multiple inheritance through classes is not permitted. Because interfaces do not contain fields, you do not have to worry about problems that result from multiple inheritance of state.



Why use interfaces - its advantages

If you start to write a simple program, you may not think about the need of using an Interface. But when you are building a larger system which keeps evolving, it is a good idea to use Interface. One of the advantage of Interface in Java is it allows multiple inheritance.It allows you to write flexible code, which can adapt to handle future requirements.

Interfaces are a way to declare a contract for implementing classes to fulfil. Interface's main goal is to create abstraction and decoupled designs between consumers and producers.

What would you like to have, hundreds of abstract methods in one single Abstract Class or make as many interfaces for specific interrelated abstract methods and only use those which you want by implementing as many interface needed ? Yes definetly you should go for interface, as it provides lot of flexibility.

abstract class A
{
 //hundreds of abstract methods();
 abstract methodA();
 abstract methodB();
 abstract methodC();
}

//OR
interface ForMethodAOnly
{
 void methodA();
}
interface ForMethodBandmethodCOnly
{
 void methodB();
 void methodC();
}

Use only those methods which are required by implementing respective interface.If you are inheriting abstract class then you have to implement many unnecessary methods, which is not a good programming practice.

"Programming to interface than implementation" is one of the popular Object oriented design principle, and use of interface promotes this. A code written on interface is much more flexible than the one which is written on implementation.

So you can say an interface is fully utilized when dependency injection techniques is used to inject required implementation on run time.Using references to interfaces instead of their concrete implementation classes helps in minimizing ripple effects, as the consumer of an interface reference doesn't have to worry about the changes in the underlying concrete implementation.

Use of interface allows you to supply a new implementation, which could be more robust, better performance in later stage of your development.

For example, XYZ comapany creates an API(Application Programming Interfaces) for converting to pdf.It writes various classes to provide the converting to pdf functionalities. So, their approach will be to create interfaces, and make classes implementing them. In this way the when the software package is delivered to clients , clients can invoke the methods by looking at the method signatures declared inside the interfaces.They won't see the actual implementation of the methods. As a result the implementation part will be a secret. Later on the company may decide to re-implement the methods in another way. But the clients are concerned about the interfaces only which is why their code wont be effected. This is the advantage of interfaces.



Differnce between Abstract class and interface

  • Methods in interface are implicitly abstract and will not have any implementations. In abstract classes there can be both abstract as well as instance methods which implements a default behavior.
  • Implementing class may implement any number of interfaces while it can only inherit from one abstract class.
  • Variables in interface are by default final while abstract class may contain non-final variables.
  • Abstract classes can have constants, members, abstract methods and defined methods, whereas interfaces can only have consts and abstract methods.
  • Interface does'nt contains construtors while abstact class contains constructors.
  • Interface in Java should be implemented using 'implements' keyword while abstract class should be extended using 'extends' keyword.
  • All the members in interface are public by default but abstract class can have all modifiers of class like protected, default, private etc.
  • When it comes to extending, abstract class rocks as it can not only extend another abstract class, but also another class and implement multiple java interfaces. On the other hand, interface can extend another java interface only.
  • On the contrary, a java class can implement multiple interfaces but it can extend only on eabstract class.
  • If speed is your thing, then abstract class should be your way as interfaces are slow when compare to abstract class as it requires extra indirection to find the actual method in the corresponding classes.[I will be writing an article about this soon].
  • Follwing difference is a major deal breaker for most of us: While using interfaces, if we add a new method to an interface, that method has to be implemented in all the classes which has implemented that interface. But if we add a new method in an abstract class, we can provide default implementation and hence all the existing code would work fine.

When to use Abstract class and interface

The choice of whether to design your functionality as an interface or an abstract class can sometimes be a difficult one.

  • An abstract class is good if you think you will plan on using inheritance since it provides a common base class implementation to derived classes.
  • An abstract class is also good if you want to be able to declare non-public members. In an interface, all methods must be public.
  • If you think you may add methods or change in the future, then an abstract class is a better choice. Because if you add new methods to an interface, then all of the classes that already implemented that interface will have to be changed to implement the new methods. That can be quite a hassle.
  • If you plan on creating multiple versions of your component, create an abstract class. Abstract classes provide a simple and easy way to version your components. By updating the base class, all inheriting classes are automatically updated with the change. Interfaces, on the other hand, cannot be changed once created. If a new version of an interface is required, you must create a whole new interface.
  • Abstract classes have the advantage of allowing better forward compatibility. Once clients use an interface, you cannot change it; if they use an abstract class, you can still add behavior without breaking existing code. If compatibility is a concern, consider using abstract classes.
  • If you plan to provide common, implemented functionality among all implementations of your component, use an abstract class. Abstract classes allow you to partially implement your class, whereas interfaces contain no implementation for any members.

    Lets look at an example which would cover above points.

    abstract class Car{	
    	public void accelerate() {
    		//do something to accelerate
    	}
    	public void applyBrakes() {
    		//do something to apply brakes
    	}	
    	public abstract void changeGears();		
    }
    
    Now, any Car that wants to be instantiated must implement the changeGears method.
    class BMW extends Car{
    	 public void changeGears(){
    		 System.out.println("Automatic gear shift");
    	 }
    }
    
    class Ford extends Car{
    	 public void changeGears(){
    		 System.out.println("6-speed manual gear shift");
    	 }
    }
    

    Now you could ask why abstract class, why not interface and ask BMW and Ford to implement that interface.Sure you can do that but you would also need to implement accelerate and applyBrakes methods in all the sub classes.By abstract classes, you can inherit the implementations of non-abstract methods, which you can't do that with interfaces.

  • If the functionality you are creating will be useful across a wide range of disparate objects, use an interface. Abstract classes should be used primarily for objects that are closely related, whereas interfaces are best suited for providing common functionality to unrelated classes.
  • Interfaces are a good choice when you think that the API will not change for a while.
  • Interfaces are also good when you want to have something similar to multiple inheritance, since you can implement multiple interfaces.
  • If you are designing small, concise bits of functionality, use interfaces. If you are designing large functional units, use an abstract class.
  • Even if you do have default implementations or internal state, consider offering an interface and an abstract implementation of it. This will assist clients, but still allow them greater freedom if desired.

    consider the following example in favor of interfaces.Lets say you have an interface for a Director and for an actor.

    public interface Actor{
       void perform();
    }
    public interface Producer{
       void invest();
    }
    

    Nowadays most of the actors are rich enough to produce their own movie. If we are using interfaces rather than abstract classes, we can implement both Actor and Producer. Also we could define a new ActorProducer interface that extends both.

    public interface ActorProducer extends Actor, Producer{
    ...
    }
    

    Yes we could achieve the same using abstract classed, but for abstract classes would require massive hierarchical type framework.

    I use base abstract classes to describe what an object is and use interface to describe capabilities of an object.
    BMW is a Car and automatic gear shift is its capabilities.
    In programming world, classes are nouns(like BMW, Ford) and interfaces are adjectives(automatic transmission, power steering). And Yes you can use both together to get the best out of both. The only drawback of doing that is calling methods via their interface name is slightly slower than calling them via their abstract class name as it requires extra indirection.