Class delegation is another interesting feature of Kotlin. How? Just think of the following situation.

You have an interface, I, and two classes, A and B. Both A and B implement I. In your code, you've an instance of A and you want to create an instance of B from that A.

In traditional inheritance, it is not directly possible; you have to write a bunch of nasty codes to achieve that, but class delegation is there to save you.

Go through the following code:

interface Person { 
    fun printName() 
} 
 
class PersonImpl(val name:String):Person { 
    override fun printName() { 
        println(name) 
    } 
} 
 
class User(val person:Person):Person by person { 
    override fun printName() { 
        println("Printing Name:") 
        person.printName() 
    } 
} 
 
fun main(args: Array<String>) { 
    val person = PersonImpl("Mario Arias") 
    person.printName() 
    println() 
    val user = User(person) 
    user.printName() 
} 

In this program, we created the instance of User, with its member property—person, which is an instance of the Person interface. In the main function, we passed an instance of PersonImpl to the user to create the instance of User.

Now, have a look at the declaration of User. After color (:), the phrase Person by person indicates that the class User extends Person and is expected to copy Person behaviors from the provided person instance.

Here is the output:

The output shows the overriding works as expected, and we can also access properties and functions of the person, just like a normal property.

A really awesome feature, isn't it?