companion and interface

Learn to implement interfaces with companion object.

companion object and interface

A companion object can implement an interface. This lets the class itself act as a factory; it can be called through an interface reference.

Example: interface Factory<T> { fun create(): T }; class User(val name: String) { companion object : Factory<User> { override fun create() = User("guest") } }. Here User.create() returns a User. You can also write val f: Factory<User> = User; the companion object is itself an object. This is useful for dependency injection and testability.

The Factory<T> interface

A Factory<T> interface declares a method that produces a value of some type. A class's companion object implements this interface to take the factory role.

Example: interface Factory<T> { fun create(): T }. The User class implements it via companion object : Factory<User> { override fun create() = User("guest") }. Calling User.create().name returns guest. A generic factory interface lets different classes produce instances through a common contract. Passing a fake factory in tests becomes easy.

Exercise A companion object implementing Factory<T>

Define a generic interface Factory<T> with a fun create(): T method. Define a class User(val name: String); implement via companion object : Factory<User> with override fun create() = User("guest"). In main print User.create().name with println.

Show example solution

interface Factory<T> {
    fun create(): T
}

class User(val name: String) {
    companion object : Factory<User> {
        override fun create() = User("guest")
    }
}

fun main() {
    println(User.create().name)
}

Test yourself

What does a companion object implementing an interface provide?
- The class creates multiple instances
- The class name can be assigned to an interface reference
- Inheritance chain shortens
- Abstract methods are deleted
Show answer

The class name can be assigned to an interface reference — When a companion object implements an interface, the class name can be assigned to an interface reference.
Match the companion + interface parts

interface Factory<T>

Interface definition
companion object : Factory<User>

Implementation
override fun create

Method implementation
User.create()

Factory call

Complete the companion + interface definition

class User(val name: String) {
    companion object : ____<User> {
        override fun create() = User("guest")
    }
}

Show answer

class User(val name: String) {
    companion object : Factory<User> {
        override fun create() = User("guest")
    }
}

Next lesson: object vs class

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies