So I have an abstract class Composition, which has two children: one is a Track, and one is an Album (which is a group of Tracks).

class Composition(val name: String, ...)
class Track(name: String): Composition(name)
class Album(name: String, val tracks: List): Composition(name)

So far, so good. Now, I have the duration that is added. It is abstract in Composition, so I can override it in the children:

abstract class Composition(...){
    abstract fun getDuration(): Int
}

Now, I can add override the method in the Track, which takes it as a parameter:

class Track(..., private val duration: Int): Composition(...){
    override fun getDuration() = duration
}

And finally, I make the Album, whose duration is the sum of the Tracks:

class Album(..., val tracks: List): Composition(...){
    override fun getDuration() = tracks.sumBy { it.getDuration() }
}

It works as intended, but I do not understand why I cannot simply use tracks.sumBy { it.duration }, since in Kotlin properties are nothing more than getters and setters (I'm thinking about the getDuration in Composition).

I feel like I'm missing something, because if the same code was written in Java, I would be able to call composition.duration as a property -- so that makes me think that Kotlin allows it from Java code, but not from Kotlin code, which is sad.

An other example:

Let's say I have a class named Artist, who wrote multiple Compositions:

class Artist(
    val nom: String,
    private val _compositions: MutableList = ArrayList()
) {

    // HERE (I wrote the extension method List.toImmutableList)
    fun getCompositions() : List = _compositions.toImmutableList()
}

This is standard in Java (exposing immutable versions of Collections via getters, so they are not modified) ; Kotlin doesn't recognize it though:

val artist = Artist("Mozart")
artist.getCompositions() // Legal
artist.compositions      // Illegal

I thought about making this a property, but: - If I choose the type List, I can override the getter to return the immutable list, but I cannot use regular methods (add...) as the List is immutable - If I choose the type MutableList, I cannot override the getter to return ImmutableList (which is a subclass of List that I wrote, and is obviously not a subclass of MutableList).

There's a chance I'm doing something ridiculous while there is an easy solution, but right now I cannot find it.

In the end, my question is: Why aren't manually-written getters considered properties when written from Kotlin?

And, if I'm mistaking, What is the expected way of solving both of these patterns?