Inheritance

Debugging Challenge

Debugging Challenge

But let’s start with some debugging practice!

First, A Puzzle

First, A Puzzle

Let’s begin this lesson with a puzzle:

If we compile and run this code, we see something printed. Which is… weird! Right? The snippet above uses dot notation to call a method on chuchu called toString. But where is that instance method defined? Do you see it? I don’t! So why does this code work? On some level, this lesson is about figuring that out.

Inheritance

Inheritance

Kotlin allows us to establish relationships between classes. Specifically, Kotlin allows one class to inherit state and behavior by extending another class. Let’s look at an example of this:

Inheritance Terminology and Syntax

Inheritance Terminology and Syntax

We use the : notation to create a relationship between two classes. In the example above, we say that Student extends Person.

Note also that the parent must be marked as open. This allows it to be extended. If we omit this keyword, attempts to extend the class will fail:

This relationship is one way. The terminology that we use here is helpful. We refer to the class that is extended as the parent and the class that extends as the child:

This helps us remember that we cannot create circular class relationships. This won’t compile:

We can also establish multiple levels of inheritance. When we do, we use similar family-based terminology:

Parent Class Initialization

Parent Class Initialization

When we extend a class, we need to make sure that our parent class is set up properly when instances of our class are created. For example, consider the hierarchy below. Whenever an instance of Student is created, we are also creating an instance of Person. So we need to make sure that the Person constructor gets called. Kotlin forces us to do this correctly. Let’s see how:

open class Person(val name: String)

class Student : Person()

val student = Student()

private

private

As a final observation, note that private still works the way that we expect. A class that extends another does not gain access to its private variables:

open class Person(private val name: String)

class Student(name: String) : Person(name) {

fun greet(): String {

return "Hello, $name"

}

}

Any

Any

However, none of this really resolves our puzzle. We still don’t know why this works:

Pet doesn’t extend anything. So where is toString coming from?

To fill in the missing piece of the puzzle, we need to meet the class that sits at the top of Kotlin’s class hierarchy, Any:

Homework Restricted to Current CS 124 Students

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

Practice: Simple Person Inheritance

Created By: Geoffrey Challen

/ Version: 2020.9.0

Create a class called Student that inherits from a class called Person. (Do not create Person. It is already available.) Define a single Student constructor that takes a String? value (name) and an Int value (university ID number), in that order. You should call the Person constructor and pass the String argument. (You don't need to do anything else with it.) Provide a publicly-readable but not writable property ID storing the university ID number. Reject negative ID numbers using require.

WorkingPrevious

Overriding Inherited Methods

Overriding Inherited Methods

So it’s nice and all that every class will inherit a toString method from Any. But this method really isn’t very useful!

For example, given that my Pet has a String name, I might want to display that instead. Can we do this? Yes! Let’s look at how:

class Pet(val name: String)

val chuchu = Pet("Chuchu")

println(chuchu.toString())

We’ll get into this more tomorrow and review exactly how Kotlin locates various method and field names when it compiles your code.

Homework Restricted to Current CS 124 Students

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

Practice: Score Tracker

Created By: Geoffrey Challen

/ Version: 2021.9.0

Create a class named ScoreTracker that we'll use to keep track of the scores of two players who are playing a game. Players playing this game always take turns, and Player 1 always plays first. Both players scores start at zero.

Each ScoreTracker should provide a method score that accepts a number of points and does not return a value. If it is Player 1's turn, the points (which might be negative) get added to their score. Otherwise they get added to Player 2's score.

You should also provide a method currentlyAhead that returns 1 if Player 1 is ahead, 2 if Player 2 is ahead, and 0 if it's a tie.

You should not expose any of your state publicly, and ScoreTracker does not need to provide a public constructor.

When your class is complete, here is how it should work:

WorkingPrevious

Homework Restricted to Current CS 124 Students

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

Homework: Rating Tracker

Created By: Geoffrey Challen

/ Version: 2022.9.0

Declare and implement a class named RatingTracker, which will store and return the average of a set of ratings. RatingTracker should not provide a constructor. It should provide one public method: addRating. addRating adds a new rating to the average, accepting a single Int value. You should require that this value is between 0 and 5, inclusive.

You should create a read-only averageRating property and override the getter appropriately so that it returns the average of all the ratings seen so far as a Double. You should require that at least one rating has been added before calling the averageRating getter. Note that in this case Kotlin will not create a so-called backing field for the property, since the value it returns is created entirely from other data!

As a reminder, here's the syntax for creating that field:

When your class is completed, here's how it should work:

You should not need to use a loop, array, or list to solve this problem. You may need to cast your values carefully when computing the average.

WorkingPrevious

CS People: Safiya Noble

CS People: Safiya Noble

If you’re like me, you use a search engine constantly. But have you ever stopped to consider where the results come from? The Internet is huge! Without search, most of us would never find our way around. And so what ends up on the first page of results matters. A lot.

Professor and MacArthur Award Winne Safiya Noble has examined how biases infiltrate Google and other search engine results in her seminal book “Algorithms of Oppression”. Listen to her describe some of her work and its broader implications:

More Practice

Need more practice? Head over to the practice page.