Getters and setters in Kotlin

Question

In Java, ad esempio, posso scrivere getter da solo (generato da IDE) o utilizzare annotazioni come @Getter in lombok - che era piuttosto semplice.

Kotlin tuttavia ha getters and setters by default. Ma non riesco a capire come usarli.

voglio farlo, consente di dire - simile a Java:

private val isEmpty: String 
     get() = this.toString() //making this thing public rises an error: Getter visibility must be the same as property visibility. 

Così come getter funzionano?

Answer 1

I getter ei setter sono generati automaticamente in Kotlin. Se si scrive:

val isEmpty: Boolean 

E 'uguale al seguente codice Java:

private final Boolean isEmpty; 

public Boolean isEmpty() { 
    return isEmpty; 
} 

Nel tuo caso il modificatore di accesso privato è ridondante - isEmpty è privato per impostazione predefinita e si può accedere solo da un getter . Quando si tenta di ottenere la proprietà isEmpty dell'oggetto si chiama il metodo get in real. Per una maggiore comprensione di getter/setter in Kotlin: due esempi di codice di seguito sono uguali:

var someProperty: String = "defaultValue" 

e

var someProperty: String = "defaultValue" 
    get() = field 
    set(value) { field = value } 

anche io voglio sottolineare che this in un getter non è vostra proprietà - è l'istanza di classe. Se si desidera ottenere l'accesso al valore del campo in un getter o setter è possibile utilizzare la parola riservata field per esso:

val isEmpty: Boolean 
    get() = field 

Se si vuole solo per avere un metodo get in accesso del pubblico - è possibile scrivere questo codice :

var isEmpty: Boolean 
    private set 

causa il modificatore privato vicino la funzione di accesso set è possibile impostare questo valore solo nei metodi all'interno del vostro oggetto.

Answer 2

Le regole sulla proprietà di accesso visibility modifiers sono i seguenti:

• Getter visibilità var e val proprietà dovrebbe essere esattamente lo stesso alla visibilità della proprietà, in tal modo è possibile duplicare solo modo esplicito la proprietà modificatore, ma è ridondante:

  protected val x: Int 
      protected get() = 0 // No need in `protected` here. 
  

• Setter visibilità var propert y dovrebbe essere uguali o meno permissivo della visibilità struttura:

  protected var x: Int 
      get() = 0 
      private set(x: Int) { } // Only `private` and `protected` are allowed. 
  

In Kotlin, sono sempre accessibili tramite getter e setter, quindi non c'è bisogno di fare una struttura private con public di accesso come in Java - its backing field (if present) è già privato.Così, modificatori di visibilità di accesso alle proprietà vengono utilizzati solo per rendere la visibilità setter meno permissiva:

• Per una proprietà con campo di supporto e di default di accesso:

  var x = 0 // `public` by default 
      private set 
  

• Per una proprietà senza campo supporto:

  var x: Int // `public` by default 
      get() = 0 
      protected set(value: Int) { } 
  

Answer 3

Getter in Kotlin è di default pubblico, ma è possibile impostare il setter su private e imposta il valore usando un metodo all'interno di una classe. Come questo.

/** 
* Created by leo on 17/06/17.*/ 

package foo 
class Person() { 
var name: String = "defaultValue" 
       private set 

fun foo(bar: String) { 
    name = bar // name can be set here 
     } 
} 

fun main(args: Array<String>) { 
    var p = Person() 
    println("Name of the person is ${p.name}") 
    p.foo("Jhon Doe") 
    println("Name of the person is ${p.name}") 
} 

Answer 4

Si può vedere questo tutorial per ulteriori informazioni:

Yet Another Kotlin Tutorial for Android Developers

Proprietà

In Kotlin mondo, le classi non possono avere campi, solo le proprietà. var parola chiave ci dice che la proprietà è mutabile, al contrario di val. Facciamo vedere un esempio:

class Contact(var number: String) { 

    var firstName: String? = null 
    var lastName: String? = null 
    private val hasPrefix : Boolean 
     get() = number.startsWith("+") 

} 

Non c'è molto codice, ma un sacco di cose stanno accadendo dietro le quinte . Lo esamineremo passo dopo passo. Innanzitutto, abbiamo creato un contatto di classe finale pubblico .

Questa è la regola primaria che dobbiamo affrontare: se non diversamente specificato, classi sono pubbliche e finale di default (a proposito, lo stesso vale per metodi di classe). Se si desidera ereditare dalla classe, contrassegnarlo con la parola chiave aperta .