Using Interfaces

abstract

abstract

But first, a short but important digression into one of the Java keywords that we have not yet covered: abstract. (Break out your Java keyword bingo cards!) Like final, abstract can be applied to both classes and methods, with somewhat different results. Let’s explore together:

// Demonstrate how to use abstract

We’ll return to abstract in a minute. But for now let’s move on!

Interfaces

Interfaces

This lesson focuses on interfaces. Like references, interfaces are ubiquitous in computer science. But let’s look at the Wikipedia definition together:

Every Object Has An Interface

Every Object Has An Interface

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:

public class Course {

private String department;

private String number;

public Course(String setDepartment, String setNumber) {

department = setDepartment;

number = setNumber;

}

public String getDepartment() {

return department;

}

public String setNumber() {

return number;

}

}

Limitations of Inheritance

Limitations of Inheritance

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:

• For numeric types, lowest to highest is a natural ordering
• For 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 Object. 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?

interface

interface

Java interfaces provide a way for classes to declare that they support certain functionality. Unlike inheritance, a single class can implement more than one interface, while still extending another class. Let’s see how this works!

interface Simple {

int simple(int first);

}

interface References

interface References

Reference variables work similarly with classes that implement interfaces as they do with polymorphism and inheritance. Let’s look at an example:

interface Simple {

int simple(int first);

}

Remember abstract?

Remember abstract?

We can achieve something similar to interfaces using abstract, but it’s not quite the same. Let’s examine the differences:

interface Simple {

int simple(int first);

}

Comparable

Comparable

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.

OurComparable

OurComparable

Java’s 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 OurComparable:

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.

interface OurComparable {

int compareTo(Object other);

}

int returnLarger(int first, int second) {

if (first > second) {

return first;

} else {

return second;

}

}

Homework Restricted to Current CS 124 Students

A publicly-accessible version of this content is available at learncs.online.

Practice: OurComparable Max

Created By: Geoffrey Challen

/ Version: 2021.3.0

Create a public class named Max with a single class method named max. max should accept an array of objects that implement OurComparable and return the maximum. Assert that the array is not null or empty.

As a reminder, compareTo returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the passed object. OurComparable works exactly the same as the official Comparable interface, except it is slightly simplified and does not accept a type parameter.

WorkingPrevious

Homework Restricted to Current CS 124 Students

A publicly-accessible version of this content is available at learncs.online.

Practice: OurComparable Is Sorted

Created By: Geoffrey Challen

/ Version: 2021.10.0

Create a public class Sorted that provides a single class method named isSorted. isSorted accepts a list of OurComparables and returns true if the list is sorted in ascending order and false otherwise. If the passed list is null or empty you should throw an IllegalArgumentException.

As a reminder, compareTo returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the passed object. OurComparable works exactly the same as the official Comparable interface, except it is slightly simplified and does not accept a type parameter.

WorkingPrevious

Homework Restricted to Current CS 124 Students

A publicly-accessible version of this content is available at learncs.online.

Homework: Compare GeoPoints

Created By: Geoffrey Challen

/ Version: 2022.10.0

One of the great things about interfaces is that we can use them to add common information to a variety of different classes where it might be appropriate. In this case, latitude and longitude information, broadly useful since many of the things we might want to model in our programs have a location on the Earth.

In this problem we'll write a so-called comparator method, which functions similarly to the Comparable interface, but instead of being called on one instance, is a static method that accepts two parameters of the same type. Create a public class CompareGeoPoints that provides a single class method named compare. compare accepts two parameters that implement the IGeoPoint interface, defined as follows:

Return -1, zero, or 1 as the first argument is less than, equal to, or greater than the second. Compare the IGeoPoints based on their longitude values only, from smallest to largest. In addition, consider two IGeoPoints within 0.00000001 of each other (measured in terms of their longitude value) as equal.

WorkingPrevious

More Practice

Need more practice? Head over to the practice page.