Advertisement

---

Top

< Prev

Next >

An interface is a 100% abstract class which is declared with the interface keyword. Methods of an interface are implicitly abstract, hence when declaring an interface, you must not provide an implementation of any of its methods and its methods should end with a semicolon ;

//Java - Example of an interface

interface A
{
	// Unlike regular methods, method of an interface 
	// should not be implemented within a pair of curly braces {} and,
	// each method of an interface should end with a semicolon.
	void getName();  
}

Some important points about interface.

• Interface methods are implicitly declared with the public access modifier and abstract keyword, which means that even if you don't explicitly type public and abstract with interface methods, they are still always public and abstract, by default.



//Java - Example of an interface

interface Math
{
	void add(int a, int b);		//add method is public and abstract by default
	void subtract(int a, int b);	//subtract method is public and  abstract by default
}


In the code above, we have created an interface Math with two methods - add() and subtract(), and they are implicitly public and abstract. Each of these methods has a void return type and takes two int parameters.





• A class can implement an interface by providing the internal logic of all methods of an interface, conforming to each of their method signatures. To implement an interface, a class must use the implements keyword.



//Java - Example of an interface

interface Math
{
	void add(int a, int b);		
	void subtract(int a, int b);	
}



//class A implementing Math interface 
class A implements Math
{
public void add(int a, int b);
{
	System.out.println(a+b);
}

public void subtract(int a, int b);
{
	System.out.println(a-b);
}
}





Program Analysis



• An interface Math is declared with two methods such as add() and subtract(), with their method signature as follows-
  • The access modifier is public by default.
  • A void return type.
  • Two int arguments in their parameters.
• A concrete class A has implemented the Math interface by providing an implementation of its two methods, by following their method signatures.
• After a class implements an interface, the implemented methods of interface are inherited and become a part of the concrete class, therefore the methods add() and subtract() are inherited by class A.






• Variables defined in an interface are implicitly public, final and static, and that's why they are called constants, which means you can't change their value and doing so gives a compile error.



//Java - Interface 

interface A
{
	int a = 10;
}

class B implements A	//B class is implementing interface A, using implements keyword
{
public void m()
{
	a = 20; //Trying to change the value of an inheritred interface constant, a
}
}





Output -




A.java:10: error: cannot assign a value to final variable a
a=20;
^
1 error






Advertisement





• You cannot instantiate or create an object of an interface, because it is a 100% abstract and skeletal. Hence, instantiating an interface gives a compile error.



//Java - You cannot create an object of an interface

interface A
{
	void methodA();
}

class B
{
public static void main(String... ar)
{
	A ob = new A();		//instantiating an interface, throws a compile error.
}
}





Output -




A.java:10: error: A is abstract; cannot be instantiated
A ob = new A();
       ^
1 error







• An Interface can extend multiple interfaces and it doesn't have to provide an implementation of the methods of any of those interfaces.



//Java - Example of Interface


interface A
{
	void methodA();
}

interface B
{
	void methodB();
}


//inteface C extending multiple interfaces without providing implementation of their methods
interface C extends A,B
{
}





Program Analysis


As you may see in the last program, an interface C has extended interfaces A and B, without providing any implementation of their methods. But, a concrete class implementing the interface C, must provide the implementation of its two methods- methodA() and methodB(), which are inherited from the intefaces A and B.





• A class can implement multiple interfaces and it must provide an implementation of all their methods.



//Java - Example of Interface


interface A			
{
	void methodA();
}

interface B
{
	void methodB();
}

interface C
{
	void methodC();
}


//class D is implementing interface A, B and C

class D implements A,B,C		
{
public void methodA()		//providing implementation of methodA() of interface A
{	
	System.out.println("A");
}

public void methodB()		//providing implementation of methodB() of interface B
{
	System.out.println("B");
}

public void methodC()		//providing implementation of methodC() of interface C
{
	System.out.println("C");
}
}





Program Analysis


Three interfaces- A, B and C are defined with their method signatures. Class D has implemented all of these interfaces and that's why, it has provided the internal logic of each of these methods in these interfaces by conforming to their signatures, and doing this was a must for class D.





• An abstract class can implement an interface and it doesn't have to implement its methods.



//Java - Example of Interface


interface Math
{
	void add(int a, int b);		//add method signature 
	void subtract(int a, int b);	//subtract method signature
}

abstract class A implements Math
{
} 


An inteface Math has two skeletal methods- add() and subtract(). An abstract class A has implemented the interface Math and hasn't provided internal logic of its methods, which is within the rules.






Why an abstract class can implement an interface without implementing its methods?


Because as per the rule of an abstract class, an abstract class may have also some skeletal methods with no definition. Hence, it doesn't have to provide an implementation of the skeletal methods of an interface while implementing it.

Please share this article -

< Prev

Next >

< Abstract Class

Final keyword in Java >

Advertisement