Setters y Getters de Kotlin

Las propiedades son una parte importante de cualquier lenguaje de programación. En Kotlin, podemos definir propiedades de la misma manera que declaramos otra variable. Las propiedades de Kotlin se pueden declarar como mutables usando la palabra clave var o como inmutables usando la palabra clave val .

Sintaxis de propiedad  

var <propertyName>[: <PropertyType>] [= <property_initializer>]
    [<getter>]
    [<setter>]

Aquí, la propiedad initializer , getter y setter son opcionales. También podemos omitir el tipo de propiedad , si se puede deducir del inicializador. La sintaxis de una declaración de propiedad inmutable o de solo lectura difiere de una mutable de dos maneras: 

1. Comienza con val en lugar de var .
2. No permite un setter.

fun main(args : Array) {
    var x: Int = 0
    val y: Int = 1
    x = 2 // In can be assigned any number of times
    y = 0 // It can not be assigned again
    }

En el código anterior, intentamos asignar un valor nuevamente a ‘ y’ pero muestra un error de tiempo de compilación porque no puede aceptar el cambio.

Setters y Getters

En Kotlin, setter se usa para establecer el valor de cualquier variable y getter se usa para obtener el valor . Getters y Setters se generan automáticamente en el código. Definamos una propiedad ‘ nombre ‘, en una clase, ‘ Empresa ‘. El tipo de datos de ‘ name ‘ es String y lo inicializaremos con algún valor predeterminado.  

class Company {
var name: String = "Defaultvalue"
}

El código anterior es equivalente a este código:  

class Company {
    var name: String = "defaultvalue"
        get() = field                     // getter
        set(value) { field = value }      // setter
}

Instanciamos un objeto ‘ c ‘ de la clase ‘Empresa {…}’. Cuando inicializamos la propiedad ‘ nombre’ , se pasa al valor del parámetro del setter y establece el ‘campo’ en valor. Cuando intentamos acceder a la propiedad de nombre del objeto, obtenemos el campo debido a este código get() = field . Podemos obtener o establecer las propiedades de un objeto de la clase usando la notación punto (.) –  

val c = Company()
c.name = "GeeksforGeeks"  // access setter
println(c.name)           // access getter (Output: GeeksforGeeks)

Programa Kotlin de Setter y Getter predeterminados 

class Company {
    var name: String = ""
        get() = field        // getter
        set(value) {         // setter
            field = value
        }
}
fun main(args: Array<String>) {
    val c = Company()
    c.name = "GeeksforGeeks"  // access setter
    println(c.name)           // access getter
}

Producción: 

GeeksforGeeks

Identificadores de valores y campos

Hemos notado estos dos identificadores en el programa anterior. 

• Valor: Convencionalmente, elegimos el nombre del parámetro setter como valor , pero podemos elegir un nombre diferente si queremos. El parámetro de valor contiene el valor al que se asigna una propiedad. En el programa anterior, hemos inicializado el nombre de la propiedad como c.name = «GeeksforGeeks», el parámetro de valor contiene el valor asignado «GeeksforGeeks».
• Backing Field (campo): Permite almacenar el valor de la propiedad en la memoria posible. Cuando inicializamos una propiedad con un valor, el valor inicializado se escribe en el campo de respaldo de esa propiedad. En el programa anterior, el valor se asigna al campo y, luego, el campo se asigna a get() .

Modificador privado

Si queremos el método get en acceso público, podemos escribir este código:  

var name: String = ""
    private set

Y, podemos establecer el nombre solo en un método dentro de la clase debido al modificador privado cerca del descriptor de acceso establecido. Programa Kotlin para establecer el valor mediante el uso de un método dentro de una clase.

class Company () {
    var name: String = "abc"
        private set
 
    fun myfunc(n: String) {
        name = n             // we set the name here
    }
}
 
fun main(args: Array<String>) {
    var c = Company()
    println("Name of the company is: ${c.name}")
    c.myfunc("GeeksforGeeks")
    println("Name of the new company is: ${c.name}")
}

Producción: 

Name of the company is: abc
Name of the new company is: GeeksforGeeks

Explicación: 

Aquí, hemos usado el modificador privado con set. Primero cree una instancia de un objeto de la clase Company() y acceda al nombre de la propiedad usando ${c.name} . Luego, pasamos el nombre «GeeksforGeeks» como parámetro en la función definida dentro de la clase. La propiedad de nombre se actualiza con el nuevo nombre y accede de nuevo.  

Setter y Getter personalizados 

class Registration( email: String, pwd: String, age: Int , gender: Char) {
 
    var email_id: String = email
        // Custom Getter
        get() {
           return field.toLowerCase()
        }
    var password: String = pwd
        // Custom Setter
        set(value){
            field = if(value.length > 6) value else throw IllegalArgumentException("Passwords is too small")
        }
 
    var age: Int = age
        // Custom Setter
        set(value) {
            field = if(value > 18 ) value else throw IllegalArgumentException("Age must be 18+")
        }
    var gender : Char = gender
        // Custom Setter
        set (value){
            field = if(value == 'M') value else throw IllegalArgumentException("User should be male")
        }
}
 
fun main(args: Array<String>) {
   
    val geek = Registration("PRAVEENRUHIL1993@GMAIL.COM","Geeks@123",25,'M')
 
    println("${geek.email_id}")
    geek.email_id = "GEEKSFORGEEKS@CAREERS.ORG"
    println("${geek.email_id}")
    println("${geek.password}")
    println("${geek.age}")
    println("${geek.gender}")
     
    // throw IllegalArgumentException("Passwords is too small")
    geek.password = "abc"   
     
    // throw IllegalArgumentException("Age should be 18+")
    geek.age= 5  
            
    // throw IllegalArgumentException("User should be male")
    geek.gender = 'F'        
}

Producción: 

praveenruhil1993@gmail.com
geeksforgeeks@careers.org
Geeks@123
25
M