Interfaces
An interface can extend any number of interfaces. The interface declaration includes a comma-separated list of all the interfaces that it extends. On the other hand a class can implement multiple interfaces. This is the term. A class can not extend interface but implements them.
Rules:
- Only a class can be instantiated. An interface can not be instantiated.
- A class that implements an interface must implement all the methods declared in the interface.
- Interfaces are types. An interface name can be used anywhere a type can be used.
Interface Hierarchy
Syntax:
An interface declaration consists of modifiers, the keyword interface.
//simple interfaces
public interface Interface1 { ... };
public interface Interface2 { ... };
public interface Interface3 { ... };
//define a group of interfaces
public interface GroupInterface extends Interface1, Interface2, Interface3 {
// constant declarations
....
// abstract methods
....
// default methods
....
// static methods
....
};
Notes:
- All methods in an interface are implicitly public, so you can omit the public modifier.
- All constant values defined in an interface are implicitly public, static, and final.
Interface Implementation
Interfaces can not be used until they are implemented. A class can implements one or more interfaces. We specify what interfaces are implemented in the class declaration statement.
Syntax:
Next is a syntax pattern for implementing a class with 3 interfaces:
public class GroupClass implements Interface1, Interface2, Interface3 {
// fields
....
// methods
....
}
Rules:
- By convention, the implements clause follows the extends clause.
- We must re-define all the abstract methods.
- Static methods do not need to be re-defined in a class.
- Default methods do not need to be re-defined in a class.
Using Interfaces
We can define an object of type interface. That's the point to have interfaces. An interface is a data type, so we can declare objects that satisfy the requirements of an interface. Once defined we can set value for it an object that is descendent of a class that implements that particular interface.
Syntax:
In next pseudo-code fragment we define a method that internally uses interfaces as types.
//create dummy interfaces
public interface Interface1 {
aMethod()
};
public interface Interface2 {
bMethod()
};
....
// define a method that uses interface objects
public void callMethods(Object obj1, Object obj2) {
//cast parameter objects to interfaces
Interface1 object1 = (Interface1) obj1;
Interface2 object2 = (Interface2) obj2;
//call methods from interfaces
object1.aMethod(); //call a method from interface 1
object2.bMethod(); //call a method from interface 2
}
Read Next: Lambda Expressions