This topic is one of the most important we'll cover this semester! Maybe we've said that before? But we really mean it this time. Interfaces are everywhere in computer science, and Java provides a great way to start understanding what they are and how they work. So let's do it!
But first, a short but important digression into one of the Java keywords that we have not yet covered:
(Break out your Java keyword bingo cards!)
abstract can be applied to both classes and methods, with somewhat different results.
Let's explore together:
We'll return to
abstract in a minute.
But for now let's move on!
This lesson focuses on interfaces. Like references, interfaces are ubiquitous in computer science. But let's look at the Wikipedia definition together:
In computing, an interface is a shared boundary across which two or more separate components of a computer system exchange information. The exchange can be between software, computer hardware, peripheral devices, humans, and combinations of these. Some computer hardware devices, such as a touchscreen, can both send and receive data through the interface, while others such as a mouse or microphone may only provide an interface to send data to a given system.
Just to be clear—while interfaces have a specific meaning in Java that we're exploring, every Java object has an interface. Let's see how:
As we've pointed out in the past, Java objects can only inherit from one class. This can lead to some problems as we design our classes.
Let's consider a real example: natural ordering. Some classes has a natural ordering, meaning that there is a well-established order. For example:
Strings, lexicographic (or dictionary) order is a natural ordering
However, not every class has such an ordering.
For example, it's not clear that the
Pet classes we've been creating have a natural ordering.
So this is an example of a feature that not every Java object has, meaning that we shouldn't add it to
But whether or not an object can implement this feature doesn't seem like it should constrain what it extends.
Where does that leave us?
interfaces provide a way for classes to declare that they support certain functionality.
Unlike inheritance, a single
implement more than one
interface, while still extending another class.
Let's see how this works!
Reference variables work similarly with classes that implement interfaces as they do with polymorphism and inheritance. Let's look at an example:
We can achieve something similar to interfaces using
abstract, but it's not quite the same.
Let's examine the differences:
As we begin with interfaces, we'll focus on using them first, and then discuss more about how to provide existing interfaces.
Let's look at one example of a useful built-in Java interface:
Comparable is what is called a parameterized interface.
We've discussed type parameters previously, but we don't want to tangle with them on interfaces quite yet.
So, instead, when we work with
Comparable we'll use our own version called
This works identically to the official
Comparable interface except without the type parameter.
Now, let's write some code together that uses the
Comparable interface to make an existing (simple) algorithm more generic.
If you plan on having a job one day, the College of LAS Life and Career Design Lab may be able to help point you in the right direction. Here's a bit more information: