Master programming syntax, solve interactive challenges & run live code in Syntaxis Explore Arena →
menu_book Course Curriculum (Kotlin) expand_more
Language Foundations
Main function Val and var Type inference Numeric types String templates Ranges Packages and imports Nullable types
Control Flow
If expression When expression For loops While loops Do while loops Break and continue Labeled returns Smart casts
Functions
Default arguments Named arguments Vararg parameters Expression body functions Local functions Higher-order functions Function references Inline functions
Classes
Primary constructors Secondary constructors Init blocks Data classes Enum classes Sealed classes Object declarations Companion objects
Inheritance and Interfaces
Open classes Overriding members Abstract classes Interfaces Delegation by Property delegation Visibility modifiers Nested and inner classes
Collections
List and MutableList Set and MutableSet Map and MutableMap Map transformation Filter transformation Fold reduction GroupBy Sequences
Null and Type System
Safe call operator Elvis operator Not-null assertion Safe casts Generic classes Generic constraints Out variance In variance
Extensions and DSLs
Extension functions Extension properties Infix functions Operator overloading Scope function let Scope function apply Scope function run Type-safe builders
Coroutines
Suspend functions Launch coroutine Async and await CoroutineScope WithContext Flow basics StateFlow Coroutine cancellation
JVM and Tooling
Java interoperability SAM conversions Annotations Reflection Use resource handling JUnit testing Gradle Kotlin DSL Serialization
Kotlin / Classes

Companion objects

Learn companion objects in Kotlin through a focused explanation, a dedicated topic-specific example, an engineering boundary, and a mastery check.

10 min read • Intermediate

companion objects is an atomic Kotlin topic inside Classes. The example uses the named construct directly so you can see its syntax, data flow, and observable behavior.

Read the code by locating the exact feature named companion objects, then trace the value before and after that feature runs. This lesson is intentionally isolated from neighboring topics: changing identifiers alone would not reproduce the same behavior because the construct itself is different.

Topic-specific example

kotlin-0032-b76ce01ab5.kt
kotlin Try It Live 
class Token private constructor(val v:String){ companion object{ fun of(v:String)=Token(v) } }
fun main(){println(Token.of("x").v)}
Edge case / engineering note

For companion objects, test the boundary that makes the feature meaningful: invalid input, an empty value, a missing branch, lifecycle/cleanup, or a type/runtime constraint. Do not infer correctness only from the happy path.

Content source & attribution
Original Syntaxis Content · Original Syntaxis Content

Lesson quizzes

Companion objects Mastery Check →
← PREVIOUS
Object declarations
NEXT →
Open classes