Introduction To Java Interface
Java is a high-level programming language that combines the power of object-oriented programming with strong static type checking. One of the key features in Java’s object-oriented toolkit is the use of interfaces in Java. In this article, we’ll be looking at interfaces, their importance, how to define and implement them, and how to use them to achieve abstraction and multiple inheritance.
What Is An Interface?
In Java, an interface is a reference type, similar to a class, that can contain only constants, method signatures, default methods, static methods, and nested types. Method bodies exist only for default methods and static methods. Interfaces cannot be instantiated—they can only be implemented by classes or extended by other interfaces. An interface is defined using the interface keyword.
Why Do We Need Interfaces?
Interfaces allow us to achieve full abstraction in Java. In an interface, we define methods without bodies, and these methods need to be implemented in the classes that implement the interface. Thus, interfaces help us define the “what” part of the behavioral contract for classes, without concerning ourselves with the “how” part.
Furthermore, interfaces are also used for achieving multiple inheritance in Java, which is not possible using classes.
Defining an Interface
An interface is defined using the interface keyword, followed by the interface name. Let’s create a simple interface:
public interface Animal {
void eat();
void sound();
}In the Animal interface, we’ve declared two methods: eat() and sound(). These methods do not have bodies—they’re just declarations.
Implementing an Interface
Once we’ve defined an interface, we can create classes that implement this interface. When a class implements an interface, it needs to provide implementations for all the methods declared in the interface. A class uses the implements keyword to implement an interface.
Let’s create a Dog class that implements our Animal interface:
public class Dog implements Animal {
@Override
public void eat() {
System.out.println("The dog eats");
}
@Override
public void sound() {
System.out.println("The dog barks");
}
}In the Dog class, we’ve provided the implementation details for the eat() and sound() methods.
Default Methods in Interfaces
Java 8 introduced a new concept known as “default methods”. These are methods in an interface that have a default implementation. They allow us to add new methods to interfaces without breaking the classes that implement these interfaces.
Here’s an example of a default method in an interface:
public interface Animal {
void eat();
void sound();
default void breathe() {
System.out.println("The animal breathes");
}
}In the above code, breathe() is a default method. When a class implements the Animal interface, it only needs to implement the eat() and sound() methods. If it doesn’t provide its own breathe() method, it will use the default one.
Conclusion
Interfaces are an integral part of Java and understanding them is essential to being able to write effective Java code. They provide a level of abstraction, enforce certain behaviours, and allow the concept of multiple inheritance. Whether you’re designing small, simple programs or large enterprise-level applications, interfaces are a powerful tool in your Java programming arsenal.
