Accessing Methods Outside Companion Object in Kotlin

1. Introduction

In Kotlin, a companion object is a special object that we create inside a class, and we use it to define static methods and properties. Nonetheless, sometimes we may wish to access methods or properties that have been declared outside the companion object from within the companion object.

In this tutorial, we’ll explore various approaches to accessing outside methods inside a companion object.

2. Using a Reference to the Outer Class

To access methods outside the companion object, we can define a reference to the outer class within the companion object and use it to call the required method:

class OuterClass {
    companion object {
        val outerClass: OuterClass = OuterClass()
        fun companionMethod(): String {
            return outerClass.outerClassMethod()
        }
    }

    fun outerClassMethod(): String {
        return "This is a method outside the companion object"
    }
}

In this code, we define a reference to the OuterClass inside the companion object via class instantiation. We then use it to call outerClassMethod() from within companionMethod().

Let’s verify our method for correctness:

@Test
fun `calls outer method using reference to outer class`() {
    val result = OuterClass.companionMethod()
        
    assertEquals("This is a method outside the companion object", result)
}

Here, we simply call the companionMethod() statically on the OuterClass. Finally, we assert that the companionMethod() method returns the correct string.

3. Passing a Reference to the Outer Class as a Parameter

We can also choose to pass an instance of the outer class to our companion object’s method as a parameter to access methods outside the companion object. For better design purposes, let’s use an interface that our outer class implements. This interface declares the method we seek to invoke in our companion object:

interface OuterClassInterface {
    fun outerClassMethod(): String
}

class OuterClassWithInterface : OuterClassInterface {
    companion object {
        fun companionMethod(outerClassInterface: OuterClassInterface): String {
            return outerClassInterface.outerClassMethod()
        }
    }

    override fun outerClassMethod(): String {
        return "This is a method outside the companion object"
    }
}

In this code, we define an interface OuterClassInterface that declares outerClassMethod(). Next, we implement this interface in the OuterClassWithInterface class and use it to access the method from inside companionMethod().

Now, let’s test this as well:

@Test
fun `calls outer method using interface`() {
    val myClass = OuterClassWithInterface()
    val result = OuterClassWithInterface.companionMethod(myClass)

    assertEquals("This is a method outside the companion object", result)
}

class ClassWithObject {
    companion object {
        fun companionMethod(): String {
            return ObjectClass.outerClassMethod()
        }
    }

    object ObjectClass {
        fun outerClassMethod(): String {
            return "This is a method outside the companion object"
        }
    }
}

@Test
fun `calls outer method using object declaration`() {
    val result = ClassWithObject.companionMethod()

    assertEquals("This is a method outside the companion object", result)
}

Finally, we can use function references to access outside methods within the companion object. In brief, we pass a reference to the required method outside as a parameter to the method in the companion object:

class ClassWithFunctionReference {
    companion object {
        fun companionMethod(outerClassMethod: () -> String): String {
            return outerClassMethod()
        }
    }

    fun outerClassMethod(): String {
        return "This is a method outside the companion object"
    }
}

In this example, our companionMethod() method takes a function reference to the outerClassMethod() method as a parameter. Next, we call this function reference from within the companionMethod() method.

This approach is flexible in that we can pass in a reference to any function with the same signature to our companion object’s method.

Let’s now test this code for correctness:

@Test
fun `calls outer method using function reference`() {
    val myClass = ClassWithFunctionReference()
    val result = ClassWithFunctionReference.companionMethod(myClass::outerClassMethod)

    assertEquals("This is a method outside the companion object", result)
}

In this test, we create an instance of the ClassWithFunctionReference class. Next, we use this instance to obtain a reference to the outerClassMethod() using the double-colon (::) operator. We then pass this reference to the companionMethod() method. Finally, we assert that this companion method returns the correct string.

6. Conclusion

In this article, we’ve explored various ways we can access methods that are declared outside a companion object from inside the companion object. Some of the approaches may be more convenient than others in certain scenarios.

For example, by passing function references as parameters, we can reuse the same method implementation with different functions. This can save time and effort by eliminating the need to write and maintain multiple similar methods. As always, we should pick the approach that best addresses our project needs.