A modern programming language that makes developers happier.

kotlinlang

Hello guys, I don't know how to use the Koltin delegation, can anyone help me understand it and what are the use cases for it?

<https://kotlinlang.org/docs/delegation.html> and <https://kotlinlang.org/docs/delegated-properties.html>

If you have specific questions, ask in <#C0B8MA7FA|getting-started>

This explanation for me helped better.  I just wish they would tell me why use this over Inheritance≥. I always struggle with the why part in Kotlin.  It seems they like to invent things but the why and when I would use this is a mystery over proven patterns.

<@U04KPH9ERM1> let's imagine you have :
```interface Game {
    val name: String

    /** `true` if [move] is legal. */
    fun canPlay(move: Move): Boolean

    fun play(move: Move)

    // some other methods…
}

class Game1 : Game {
    override val name get() = "Game 1"
    …
}

class Game2 : Game {
    override val name get() = "Game 2"
    …
}```
What if you wanted to create variants of games where you can only play 3 moves? With regular inheritance you'd have to create a new class for each `Game` subclass! With composition (implemented using delegation):
```// Takes a Game implementation as parameter, and adds the maximum move count rule to it
class LimitedGame(private val game: Game, private val maxCount: Int) : Game by game {
    private var currentCount = 0

    override val canPlay(move: Move): Boolean {
        if (currentCount &gt;= maxCount)
            return false
        currentCount++
        return game.canPlay(move)
    }

    // no need to implement the other methods, they are all delegated to the original game instance
}```


&gt; over proven patterns
Composition is a proven pattern. For example, it's item 16 in Effective Java, which doesn't even have composition at the language feature. It's also mentioned in the original Design Patterns book from 1994

(btw I recommend reading that item of Effective Java, it gives other examples of when to use it and describes in more details why it's useful)

See also: <https://en.wikipedia.org/wiki/Composition_over_inheritance>

I forgot about the link I read.  But thanks this makes it better to understand the when and why.  <https://en.wikipedia.org/wiki/Delegation_pattern>