Object expressions (anonymous objects) in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is an object expression in Kotlin?

An object expression creates an anonymous object, which is an instance of a class without explicitly declaring the class. It allows you to define and instantiate a class at the same time.

intermediate

How do you create an anonymous object that implements an interface in Kotlin?

You use an object expression with a colon and the interface name, then provide the implementation inside curly braces. For example:

val obj = object : MyInterface { override fun doSomething() { /*...*/ } }

beginner

Can anonymous objects have properties and methods in Kotlin?

Yes, anonymous objects can have their own properties and methods defined inside the object expression, just like regular classes.

beginner

What is a common use case for object expressions in Kotlin?

They are often used to create quick implementations of interfaces or abstract classes, especially for event listeners or callbacks, without creating a separate named class.

intermediate

What is the difference between an object declaration and an object expression in Kotlin?

An object declaration defines a singleton with a name and is created once. An object expression creates an anonymous object instance on the spot without a name.

How do you create an anonymous object in Kotlin?

A Using the 'object' keyword followed by a colon and a class or interface

B Using the 'class' keyword without a name

C Using the 'new' keyword

D Using the 'fun' keyword

In Kotlin, anonymous objects are created using 'object' keyword optionally followed by a colon and a class or interface to implement.

Can anonymous objects in Kotlin have properties?

A Only if they implement an interface

B No, they can only have methods

C No, they cannot have properties or methods

D Yes, they can have properties and methods

Anonymous objects can have their own properties and methods defined inside the object expression.

What is a typical use of object expressions in Kotlin?

A To define data classes

B To create quick implementations of interfaces or abstract classes

C To declare global variables

D To create named singletons

Object expressions are commonly used for quick implementations of interfaces or abstract classes, such as event listeners.

What keyword is used to create an anonymous object in Kotlin?

A interface

B class

C object

D new

The 'object' keyword is used to create anonymous objects in Kotlin.

What is the difference between an object declaration and an object expression?

A Object declaration creates a named singleton; object expression creates an anonymous object instance

B Object declaration creates anonymous objects; object expression creates named classes

C Both are the same

D Object declaration is used only for interfaces

Object declarations define named singletons, while object expressions create anonymous object instances.

Explain what an object expression is in Kotlin and how it differs from a regular class.

Think about creating a quick object without naming a class.

Describe a practical scenario where you would use an object expression in Kotlin.

Consider when you want to handle an event without extra class clutter.

Practice

1. What is an object expression in Kotlin?

easy

A. A named class declaration

B. A way to create an anonymous object with properties and functions

C. A function that returns a string

D. A variable declaration with a fixed value

Solution

1. Step 1: Understand object expressions

   Object expressions create unnamed objects on the spot with properties and functions.

2. Step 2: Differentiate from other options

   Named classes, functions, and variables are different concepts and do not create anonymous objects.

3. Final Answer:

   A way to create an anonymous object with properties and functions -> Option B

4. Quick Check:

   Object expression = anonymous object [OK]

Hint: Anonymous objects = quick unnamed objects [OK]

Common Mistakes:

• Confusing object expressions with named classes
• Thinking object expressions are functions
• Assuming object expressions are variables

2. Which of the following is the correct syntax to create an anonymous object in Kotlin?

easy

A. val obj = object() { val x = 10 }

B. val obj = class { val x = 10 }

C. val obj = object { val x = 10 }

D. val obj = fun() { val x = 10 }

Solution

1. Step 1: Recall Kotlin object expression syntax

   The correct syntax uses object { ... } without parentheses.

2. Step 2: Check each option

   val obj = object { val x = 10 } matches the correct syntax. val obj = class { val x = 10 } uses class which is invalid here. val obj = fun() { val x = 10 } uses fun() which is a function, not an object. val obj = object() { val x = 10 } incorrectly adds parentheses after object.

3. Final Answer:

   val obj = object { val x = 10 } -> Option C

4. Quick Check:

   Correct syntax = object { ... } [OK]

Hint: Use 'object { }' without parentheses for anonymous objects [OK]

Common Mistakes:

• Adding parentheses after 'object'
• Using 'class' instead of 'object'
• Confusing functions with object expressions

3. What will be the output of this Kotlin code?

val obj = object {
    val name = "Alice"
    fun greet() = "Hello, $name!"
}
println(obj.greet())

medium

A. Runtime error

B. Hello, name!

C. Compilation error

D. Hello, Alice!

Solution

1. Step 1: Analyze the anonymous object

   The object has a property name with value "Alice" and a function greet() that returns "Hello, $name!".

2. Step 2: Evaluate the print statement

   Calling obj.greet() returns "Hello, Alice!" which is printed.

3. Final Answer:

   Hello, Alice! -> Option D

4. Quick Check:

   obj.greet() = "Hello, Alice!" [OK]

Hint: Object properties accessed inside functions print correctly [OK]

Common Mistakes:

• Expecting variable name printed instead of value
• Thinking anonymous objects cause errors
• Confusing string interpolation syntax

4. Identify the error in this Kotlin code using an object expression:

val obj = object {
    val x = 5
    fun printX() {
        println(y)
    }
}

medium

A. Property 'y' is not defined in the object

B. Missing parentheses after 'object'

C. Function printX() should return a value

D. Cannot use println inside object expressions

Solution

1. Step 1: Check properties and functions inside the object

   The object defines property x but tries to print y which is not defined.

2. Step 2: Understand the error cause

   Accessing undefined property y causes a compilation error.

3. Final Answer:

   Property 'y' is not defined in the object -> Option A

4. Quick Check:

   Undefined property access = error [OK]

Hint: Check all properties used inside object functions exist [OK]

Common Mistakes:

• Assuming missing parentheses after 'object' cause error
• Thinking functions must return a value
• Believing println is disallowed inside objects

5. How can you use an object expression to create a one-time comparator for sorting a list of strings by length in Kotlin?

hard

A. list.sortedWith(object : Comparator<String> { override fun compare(a: String, b: String) = a.length - b.length })

B. list.sortedWith(object Comparator<String> { fun compare(a: String, b: String) = a.length - b.length })

C. list.sortedWith(object : Comparator<String> { fun compare(a: String, b: String) = a.length - b.length })

D. list.sortedWith(object Comparator<String> { override fun compare(a: String, b: String) = a.length - b.length })

Solution

1. Step 1: Understand object expression with interface implementation

   To create a comparator, use object : Comparator<String> and override compare method.

2. Step 2: Check syntax correctness

   list.sortedWith(object : Comparator<String> { override fun compare(a: String, b: String) = a.length - b.length }) correctly uses override fun compare. Options B and D miss the colon before interface or override keyword. list.sortedWith(object : Comparator<String> { fun compare(a: String, b: String) = a.length - b.length }) misses override keyword.

3. Final Answer:

   list.sortedWith(object : Comparator<String> { override fun compare(a: String, b: String) = a.length - b.length }) -> Option A

4. Quick Check:

   Correct syntax = object : Interface { override fun method() } [OK]

Hint: Use 'object : Interface { override fun method() }' for anonymous implementations [OK]

Common Mistakes:

• Omitting colon before interface name
• Missing override keyword on method
• Using 'object Interface' instead of 'object : Interface'