Implement An Interface

Not to be confused with a graphical interface, interface in OOP is a CONTRACT with a promise to fulfill BETWEEN two parties—a class and the outside world (its interface). When a class “implements” an interface it promises to provide the methods (behaviors) of that interface.

Methods form the object’s INTERFACE with other outside objects—the class’ API.

• An interface is a group of method signatures with no code implementation in them.
• An interface has a set of methods with corresponding typed parameters and a return datatype that a class must minimally implement to be considered valid.

An interface is CREATED similar to a class but it uses the keyword interface instead of class:

interface MyBox {
void setHeight (int newHeight);
void setWidth (int newWidth);
void setColor (String newColor);
}

NOTES:
- All of the code from the class MyBox was deleted except the method signatures and the class definition has been changed to an interface definition.

QUESTION: Can you convert a class to an interface in Android Studio?

An interface is USED by using the keyword implements with the class you want to “implement.”

class MyCustomBox implements MyBox {
int height=100;
int width=100;
string color = “blue”;

void setHeight (int newHeight) {
height = newHeight;
}

void setWidth (int newWidth) {
height = newWidth;
}

void setColor (int newColor) {
color = newColor;
}

}

NOTE:  To actually compile the MyCustomBox class, you'll need to add the public keyword to the beginning of the implemented interface methods. This will be discussed later.

NOTES:

• Notice that the class name has been changed (to a particular brand of Box—MyCustomBox).
• The compiler will require that all of the mehods (setHeight, setWidth, setColor) of the interface being implemented; otherwise, it will throw an error.
• Implementing an interface allows a class to become more formal about the interface methods it provides.
• The benefit of implementing an interface is that later you could have many classes choose to implement the same interface and other sections of the app can use object with interfaces without knowing how those objects work. The more classes that implement the same interface the better.