Kotlinlearncs.online LogoJava

    ← Prev

    Index

    Next →

    Kotlin
    Java

    • Anonymous Classes : 42

    • Practice with Interfaces : 41

    • Implementing Interfaces : 40

    • Using Interfaces : 39

    • Working with Exceptions : 38

    • Throwing Exceptions : 37

    • Catching Exceptions : 36

    • References and Polymorphism : 35

    • References : 34

    • Data Modeling 2 : 33

    • Equality and Object Copying : 32

    • Polymorphism : 31

    • Inheritance : 30

    • Data Modeling 1 : 29

    • Companion Objects : 28

    • Encapsulation : 27

    • Constructors : 26

    • Objects, Continued : 25

    • Introduction to Objects : 24

    • Compilation and Immutability : 23

    • Practice with Collections : 22

    • Maps and Sets : 21

    • Lists and Type Parameters : 20

    • Imports and Libraries : 19

    • Multidimensional Arrays : 18

    • Practice with Strings : 17

    • null : 16

    • Algorithms and Strings : 15

    • Strings : 14

    • Functions and Algorithms : 13

    • Practice with Functions : 12

    • More About Functions : 11

    • Errors and Debugging : 10

    • Functions : 9

    • Practice with Loops and Algorithms : 8

    • Algorithms I : 7

    • Loops : 6

    • Arrays : 5

    • Compound Conditionals : 4

    • Conditional Expressions and Statements : 3

    • Operations on Variables : 2

    • Variables and Types : 1

    • Hello, world! : 0

    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

    Solve: String Length Comparable Parameterized (Practice)

    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.

    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.

    More Practice

    Need more practice? Head over to the practice page.