Introduction to Interface in Java
The Interface is a medium to interact between user and system devices. For example, in our real-life, if we consider the interface to be given as an example is the air condition, bike, ATM machine, etc. Similarly, in Java Interface also plays the same role it is considered as an interactive medium between the system and the end-user. Although the main aim of the interface in java is to achieve 100% abstraction by hiding actual implementation to the user and thus making applications bit user-friendly. It basically comprises of static, abstract and final methods.
Syntax:
interface <interface name> {
// declare constant variables
// declare abstract methods
// declare default modifier
// by default
}
Why Do We Need Interface in Java?
There are three main reasons why do we need an interface in java:
- The very first need is to make the application very user-friendly which can be done by making two different systems communicate via each other smoothly via interface [i.e. by making a java application talk with the mainframe systems through an interface.]
- Applications will be enhanced and optimized as well as simplified as its internal implementation is not the concern of the end-user.
- The most important of all is that application becomes secured as the implementation after making abstract is hidden from the outside world thus maintaining the security aspects as well.
- The functionality of the multiple inheritances also becomes supportable.
- As it is most often defined as IS-A-Relationship it is used to achieve loose coupling.
How Does the Interface Work in Java?
If we see a bigger picture of java then interface plays a very pivotal role in a way that any service requirement specification is considered as an interface. With the client-side perspective of expecting a set of services to be delivered to the end-user is known as interface and from the perspective of service providers, the set of services being offered is known as the interface.
Therefore, as mentioned earlier with real-life example an interface in java is nothing but a contract between the client-side and service providers. The abstract class consists of both abstract class as well as normal methods or non-abstract classes but the case is not the same with the interface. The interface in java has really helped the main framework of applications to make them secured and came a lot way to become user-friendly. It maintains IS-A-Relationship which also helps in making inheritance and extending between classes possible thus providing visibility.
The nested interface is yet another type of interface that we can suggest by its name as an interface within an interface and comes as a part of nested classes as well.
4.8 (4,768 ratings)
View Course
How to Declare Interface in Java?
By declaring interface keyword: We can declare an interface by using the interface keyword and implement it by using the implement keyword.
Example:
interface Interf
{
void m1(); // by default public abstract void m1();
voidm2();
}
Implementation of Interface in Java
Implementation of an interface in java is performed by using implements keywords.
interface Interfc
{
void m1();
void m2();
}
abstract class ServiceProvider implements Interfc
{
public void m1()
{
}
}
Therefore, if a class implements an interface mandatorily, we should provide an implementation for every method of that interface otherwise that class must be declared as abstract. If an interface is getting implemented, then it is a must to declare the interface as public otherwise it will throw an error saying compile-time error.
Then there is one more very important aspect to be followed with interface declaration and implementation.
Examples to Implement Interface in Java
Following are the examples to implement an interface in java with different scenarios:
Example #1
public class Cat implements Animal {
public interface Animal
{
public void animalRuns ();
public void Sleep ();
}
public void animalRuns ()
{
System.out.println("The cat says meow meow");
}
public void Sleep()
{
System.out.println("cat sleeps");
}
public static void main(String[] args)
{
Cat myCat = new Cat();
myCat.animalRuns();
myCat.Sleep();
}
}
Output:
The above output tries to prove the point that the interface must be implemented by another class using implements keyword rather than using the extends keyword.
Example #2
Implementation of Multiple Interfaces:
public class DemoClass implements frstInterface, secInterface {
public interface frstInterface
{
public void myMethod ();
}
public interface secInterface
{
public void scnInterface();
}
public void scnInterface () {
System.out.println("Some random Text");
}
public void myMethod() {
System.out.println("Some useful Text");
}
public static void main (String[] args) {
DemoClass myDemo = new DemoClass();
myDemo.myMethod();
myDemo.scnInterface();
}
}
Output:
Example #3
One interface can extend another interface also once class can implement an interface.
public class TestImpl4 implements showble
{
public interface Printable
{
void print();
}
public interface showble extends Printable
{
void show();
}
public void print()
{
System.out.println("Hello");
}
public void show()
{
System.out.println("Welcome to the project");
}
public static void main(String[] args)
{
TestImpl4 obj = new TestImpl4();
obj.print();
obj.show();
}
}
Output:
Conclusion
Many times, people get confused between abstract class and interface, but they are different. An interface contains only abstract method but java 8 can accommodate both default and static methods also which is like add on. The interface gives its 100% and can achieve full abstraction but this is not the case with the abstract class which provides partial abstraction only.
Recommended Articles
This is a guide to Interface in Java. Here we discuss the introduction and how does the interface work in java along with examples to implement an interface in java. You may also look at the following articles to learn more –
