Kotlinlearncs.online LogoJava

Anonymous Classes

interface Adder {
fun addTo(value: Int): Int
}
val addOne = object : Adder {
override fun addTo(value: Int) = value + 1
}
val addEight = object : Adder {
override fun addTo(value: Int) = value + 8
}
println(addOne.addTo(1))
println(addEight.addTo(1))
println(addOne.addTo(8))

This lesson ventures into interesting uncharted territory. Until now, our classes have needed to have names. But Kotlin doesn’t actually require this! Let’s explore anonymous classes and their uses…

Please note that the next two lessons are on fairly advanced topics. You will see and need to understand code that uses these ideas, but testing on them will be limited.

Warm Up Debugging Challenge
Warm Up Debugging Challenge

But… hold on! Let’s warm up with another debugging challenge!

Create and complete the implementation of the Circle class. Your class should inherit from the Shape class, and provide the following methods:

  1. Constructor that takes a Double parameter. Creates a new Circle with the passed radius. You can assume that the passed radius is greater than zero. You should call the Shape constructor and pass it the String "circle" to identify the type of this shape.
  2. Implement the Shape method area that takes no arguments and returns a double. Return the area of this shape: Math.PI * radius * radius.
  3. Override fun equals(other: Any?): Boolean. Return true if other is a Circle with the same radius, and false otherwise. Note that other may be null or not a Circle.

Finally, note that your class should not expose any of its internal state publicly.

Anonymous Classes
Anonymous Classes

We’ve seen how to define what is called a named class. This should be familiar to us by now:

// Person is a named class
class Person

However, Kotlin also allows us to define so-called anonymous classes. Let’s go through an example carefully:

open class Person {
open fun getType(): String {
return "Person"
}
}
val person = Person()
val student = object : Person() {
override fun getType(): String {
return "Student"
}
}
println(person.getType())
println(student.getType())

In contrast to named classes, anonymous classes:

Capturing Variables
Capturing Variables

Anonymous classes can capture the value of variables that are available when they are created. This can be extremely useful, even if the results are a bit spooky. Let’s look at an example:

open class Person {
open fun getType(): String {
return "Person"
}
}
// Show variable capture

Uses for Anonymous Classes
Uses for Anonymous Classes

We can create anonymous classes in Kotlin. Cool! But… so what!? What problems can these classes solve?

Surprisingly, anonymous classes turn out to be common and quite powerful. Let’s look at an example.

Imagine that we want to count the number of elements in an array of Ints that meet some condition. The condition could be that the element was positive, or negative, or odd, or even, or divisible by three, or whatever.

One approach would be to write separate methods for each thing we would want to count:

fun countArrayPositive(values: Array<Int>): Int {
var count = 0
for (value in values) {
if (value >= 0) {
count++
}
}
return count
}
fun countArrayNegative(values: Array<Int>): Int {
var count = 0
for (value in values) {
if (value < 0) {
count++
}
}
return count
}
fun countArrayEven(values: Array<Int>): Int {
var count = 0
for (value in values) {
if (value % 2 == 0) {
count++
}

Wow, this is getting tedious—and we’ve only done three! Imagine if we had a bunch of different conditions we needed to handle… But they are all very similar. There must be a better way.

Let’s see how to rewrite the code above using an anonymous class in a way that makes the counting logic completely flexible.

fun countArrayPositive(values: Array<Int>): Int {
var count = 0
for (value in values) {
if (value >= 0) {
count++
}
}
return count
}
fun countArrayNegative(values: Array<Int>): Int {
var count = 0
for (value in values) {
if (value < 0) {
count++
}
}
return count
}
val array = arrayOf(1, 2, 5)
println(countArrayPositive(array))

Practice: Bracket an Anonymous Class

Created By: learncs.online Staff
/ Version: 2020.10.0

Declare a method create. create takes a single Int parameter and returns an anonymous object that implements the Bracket interface:

The returned object should implement top so that it returns the passed Int and bottom so that it returns the passed Int * -1. So, for example:

Homework: String Both Ways Anonymous Class

Created By: learncs.online Staff
/ Version: 2021.10.0

Declare a method create. create takes a single String parameter and returns an anonymous object that implements the IBothWays interface:

So, for example:

More Practice

Need more practice? Head over to the practice page.