Why Java Interfaces Are So VERY Cool
- Let's Get One Thing Straight
- Some Reasons Why Interfaces Are Very Cool
- How to Write an Interface
- Interfaces Versus Abstract Classes
- Constants
- Interface Inheritance
- Implementing Interfaces
This chapter is from the book
This chapter is from the book
This chapter is from the book
El Objectivos:
Learn It
Live It
Love It
The interface is Java's answer to multiple inheritance. It is a Java type that defines what should be done, but not how to do it. Interfaces are perhaps most useful when designing the API for your program. In this topic, we'll find out how to define an interface, how to implement one, and how to use it in program design.
Let's Get One Thing Straight
Let's get one thing straight. Right off the bat. There are really two ways that people in Javaland use the term interface. One is conceptual and one is concrete.
People sometimes talk about a program's interface, or even a class' interface. Remember that API is an acronym for Application Programming Interface. When used this way, it means the thing with which we interact. It's what is exposed to us that we can work with. It is the visible boundary of a class or a program or a programming language's libraries. This is the conceptual version of the term interface. It means the public (I really mean non-private) methods that we can call to do something.
On the other hand, an interface is a Java programming language construct, similar to an abstract class, that allows you to specify zero or more method signatures without providing the implementation of those methods. Remember the implementation is the code block that does the work. Let's look at the difference.
public void printMessage(int numberOfTimes); // a method declaration in an interface.
The preceding code is an example of an interface method declaration. Notice how the signature ends in a semi-colon. There is no code that does the actual work of the printMessage() method.
An interface will consist of method signatures that look like this; there can be no implementation at all. You do the implementation in a class. An implementation of the printMessage() method might look like this.
public void printMessage(int numberOfTimes) {
for (int i = 0; i <= numberOfTimes; i++) {
System.out.println("Current message number " + i);
}
}
Or the implementation could be different. Maybe a different implementation uses a while loop, and has a different String message, or doesn't print the current iteration of the loop as represented by i.
Imagine an interface with some method signatures, and a class that will implement the interface.
Interface: I have 5 method signatures.
Class: I want to implement them.
Interface. Okay. But then you have to implement all of them. You are not allowed to say that you implement me without implementing every single one of my methods.
Class: It's a deal.
An interface is a contract. It is binding between the interface and the class that implements the interface.
But why in the world would you want to do that? A class can implement whatever methods it wants. Why not cut out the middleman, go ahead and implement the methods you want, and then forget about the interface altogether? Well, you could do that. But there are actually several reasons why interfaces are very cool.
If it helps, you can think of an electrical outlet.
An electrical outlet is a wonderful invention. It is really, really a cool thing, the electrical outlet. The interface for every electrical outlet is exactly the same (okay, they're different in the United States than other places, and sometimes you get three little holes to plug stuff into, and sometimes only two; work with me here. Geez). You know that you will be able to use the electricity you need for your laptop, PlayStation, hair drier, or electric dog polisher as long as each of them have standard cords that will plug into an outlet. We could imagine a hypothetical interface called Pluggable that means that it has a standard set of prongs that will plug into a standard outlet. A bowl does not implement the Pluggable interface. Can't plug it in. The book "The Complete William Shakespeare" doesn't implement the Pluggable interface. Can't plug it in. However, an e-book reader does implement the Pluggable interface. You could read "The Complete William Shakespeare" on e-book or in paper form. Same text. Different implementation.
So back to our story.