kotlin 中显式 getter 的目的是什么？

Question

Using getters and setters is a very well known practice in object oriented languages. This is done in order to have a greater control on the variables. To achieve this, we make the variables private in java and hence we need both getters and setters there.

But in kotlin this is not the case. Here even public variables are accessed through getters and setters by default. Though setters can be used to validate an assignment to a variable, getters just return the variable as it is stored (and I think this is it for them). Hence custom getters are not required at all.

I have also seen some wrong usage of this feature where instead of writing a zero argument function, they use a val and do the computation in the getter. This creates an illusion that the thing is just a val but in reality it does not store anything and instead it performs a computation every time.

So is there a real need to have a custom getter?

Answer 1

getters just return the variable as it is stored (and I think this is it for them). Hence custom getters are not required at all.

If that was really the case, why have getters at all in Java? One of the goals of encapsulation is to make sure a change in the class doesn't change it's API. It's the same in Kotlin.

I have also seen some wrong usage of this feature where instead of writing a zero argument function, they use a val and do the computation in the getter. This creates an illusion that the thing is just a val but in reality it does not store anything and instead it performs a computation every time.

This is a perfectly valid use case for a custom getter. In Kotlin, one must not assume that using a property is entirely free of overhead. There are many questions to ask yourself when choosing between a property with a getter or a zero-arg function:

• Does it describe behavior? Use a function ( walk() , build() , etc)
• Does it describe state? Use a property ( firstName , lastIndex , etc)

Additionally, a property getter should not throw an exception, should be either cheap to calculate or cached on first access, and should return the same result for multiple consecutive executions. Here's examples from the standard library:

• ArrayDeque.first() is a function, it throws if deque is empty.
• List.lastIndex is a property, it's cheap to calculate.
• Lazy<T>.value is a property, the value is computed and cached on first access.

Most delegated properties make use of custom getters.

More reading:

• Why use getters and setters/accessors?
• Kotlin: should I define Function or Property?

Answer 2

Just some more info. Other than readability, the possibility of defining a custom getter allows you to evolve a class without changing its public members, even if you started with a simple val with no custom getter.

In a language without properties like Java, if you define a public field:

public class Foo {
    public final int value;

    public Foo(int value) {
        this.value = value;
    }
}

And then later you want to modify the class to add a feature where it returns negated values if you flip a Boolean, there's no way to do it without breaking code that uses the original version of the class. So you should have used getters and setters to begin with.

But in Kotlin, you can't directly expose a backing field like this, so it's impossible to paint yourself in a corner like you could with a public field in Java. If your original class is like this:

class Foo(val value: Int)

You could modify it like this to add the feature and have no impact on code that already uses the class.

class Foo(private val originalValue: Int) {
    var isNegated = false

    val value: Int
        get() = if (isNegated) -originalValue else originalValue
}