KotlinCS 124 LogoJava

Practice with Interfaces

class Countdown(private var start: Int) : Iterable<Int>, Iterator<Int> {
override fun iterator(): Iterator<Int> {
return this
}
override fun next(): Int {
return start--
}
override fun hasNext(): Boolean {
return start >= 0
}
}
val countdown = Countdown(8)
for (value in countdown) {
println(value)
}

Next we’ll get more practice working with interfaces. We’ll move past our friend Comparable and look at two new interfaces that allow us to integrate with a built-in language feature—the for in loop. Super cool! Let’s go…

Iterable and Iterator
Iterable and Iterator

Let’s have more fun with interfaces.

Remember our good old for loop?

val longs = arrayOf(1L, 2L, 5L)
for (value in longs) {
println(value)
}

So it turns out that we can implement our own classes that can be used in the for loop. Pretty cool! Let’s look at the interfaces that are required and consider how they work. We’ll examine them both at once, since they are really designed to work together:

Random Number Iterator
Random Number Iterator

Now let’s put what we know to use to build a simple random number generator. We’ll create a class that can be used on the right side of a for loop and generates a certain number of random Int values.

// Random Int Iterable

A Few Improvements
A Few Improvements

Next, let’s look at a few improvements to our iterable random number generator based on what we’ve already done.

// Random int Iterable

Practice: Solve String Length Comparable Parameterized

Created By: Geoffrey Challen
/ Version: 2021.10.0

Create a public class named MyString. MyString should provide a public constructor that accepts a single String argument. Your string variable should be private.

MyString should also implement the Comparable interface. Normally Strings are compared lexicographically: "aa" comes before "z". MyString should compare instances based on the length of its stored String. So MyString("aaa") should come after MyString("z"), since "aaa" is longer than "z".

Note that you should implement Comparable<MyString>, meaning that MyString instances can be compared with other MyString instances but not with other objects. As a result, the signature of compareTo will be fun compareTo(other: MyString): Int, accepting a MyString rather than Any.

You will probably need to review the documentation for Comparable.

Practice: Solve Both Greater Comparable

Created By: Geoffrey Challen
/ Version: 2021.10.0

Create a class named BothGreater that stores two Int values set by the primary constructor. Neither should be publicly visible. BothGreater should also implement the Comparable<BothGreater> interface, returning 1 for a positive result and -1 for a negative result. An instance of BothGreater is greater than a second instance if both Int values are larger, and is lesser than if both Int values are smaller. Otherwise, compareTo should return 0.

You will probably need to review the documentation for Comparable. (Note that this is Java documentation.) Because we are using the type parameter BothGreater to the Comparable interface, compareTo accepts an BothGreater as an argument.

Homework: Solve Closer To A Pole

Created By: Geoffrey Challen
/ Version: 2022.10.0

Create a class named Position that stores two Double fields set by the primary constructor: a latitude and longitude value, passed in that order. Neither should be publicly visible. Your constructor should reject invalid latitude and longitude values. Valid longitude values are between -180.0 and 180.0, inclusive, while valid latitude values are between -90.0 and 90.0, inclusive.

Position should also implement the Comparable<Position> interface, returning 1 for a positive result and -1 for a negative result. An instance of Position is greater than a second instance if it is closer to either the North or South Pole, is lesser than the second instance if it is farther from the North or South Pole, and equal if it is at the same distance. The instance passed to compareTo will not be null.

You will probably need to review the documentation for Comparable. (Note that this is Java documentation.) Because we are using the type parameter Position to the Comparable interface, compareTo accepts an Position as an argument.

More Practice

Need more practice? Head over to the practice page.