Clases en Kotlin: clases vacias, constructores y propiedades

08-03-2018 - Andrés Cruz

Clases en Kotlin: clases vacias, constructores y propiedades In english

Este material forma parte de mi curso y libro completo; puedes adquirirlos desde el apartado de libros y/o cursos.

Las clases en Kotlin como veremos en las siguientes dos entradas están simplificadas para escribir la mayor cantidad de funcionalidades con la menor cantidad de código; la sintaxis es simple o en el peor de los casos similares a los de otro lenguaje como Java cuenta (recordemos que sigue el mismo paradigma de orientado a objetos) con los mismos conceptos de constructores, herencia, interfaces, clases abstractas que en Java (aunque con una diferencia sustancial en el manejo de las propiedades); para definir una clase en Kotlin tenemos:

Primeros pasos con las clases: clases vacías

Para definir una clase en Kotlin en su mínima expresión tenemos que:

class Vacia

Como vemos, en Kotlin, para crear una clase pública (por defecto al no estar definido otro tipo de clase) no hace falta definir llaves ni nada por el estilo, ya que no tiene propiedades u otro método; también podríamos definir la clase anterior con las llaves:

class Vacia {}

Aunque las mismas son opcionales dependiendo de si definimos propiedades y métodos dentro de la clase; pero como mínimo debemos definir una clase que podemos llamar como vacía, es decir que no cuente con ningún tipo de propiedades o métodos en la misma y las llaves.

Instanciar clases:

Para instanciar la clase anterior sería de la siguiente manera:

val vacia = Vacia ()

Los () sirven para indicar el método constructor, que para este ejemplo es el por defecto de la clase Vacia; Ademas note que no empleamos la palabra reservada de otros lenguajes de programación como Java new que es empleada en Java para indicar la creación de un nuevo objeto.

Aunque una clase sin nada adentro o nada definido no nos sirve de mucho; para eso tenemos las propiedades que veremos a continuación.

Propiedades de las clases en Kotlin

Las clases nos sirven para referenciar objetos del mundo real, y mediante las propiedades podemos definir las distintas características que nos interese manipular con las cuales conste ese objeto; por ejemplo, para definir una clase Persona en Kotlin con algunas propiedades (sí, propiedades y no atributos) podemos hacer lo siguiente:

class Persona {
var nombre: String = ""
var apellido: String = ""
var edad: Int = 0
}

Las properties o propiedades en sustitución de las variables

Las properties o propiedades en Kotlin son algo innovador que nos facilitarán bastantes las cosas al momento de construir nuestras clases; ya que sustituyen a los getters y setters que tenemos que emplear en otros lenguajes como Java; con esto logramos una simplificación enorme en la cantidad de código que tenemos que crear en nuestras clases orientadas a objetos o que definen una entidad o algo por el estilo; por ejemplo, una persona, no tenemos que definir los gets y sets para el nombre, apellido, etc, si no simplemente declarar la propiedad como si de una variable se tratase.

Ahora vamos a volver a crear una instancia de una clase, en este caso de la clase llamada Persona y vamos a acceder a las propiedades que definimos anteriormente:

val persona = Persona()
persona.nombre = "Andrés"
persona.apellido = "Cruz"

Para acceder a cada uno de ellos podemos es igual de facil:

println(persona.nombre) println(persona.apellido)

Propiedades, mas no variables en las clases de Kotlin

Un punto muy importante es lo que veníamos diciendo antes hay un cambio de concepto entre Kotlin y Java, mientras que en Java las propiedades nombre y apellido para este ejemplo serían campos en Kotlin son propiedades, esto nos trae que en Java se considera una mala práctica de programación que accedemos a las campos directamente como hicimos anteriormente, pero en Kotlin no, en Kotlin los métodos GET y SET son inferidos por el compilador, cosa que no ocurre en Java y esto se debe a esta diferencia de conceptos que señalamos anteriormente; puedes obtener más información en Kotlin Getters and Setters y es importante que sepas este cambio de paradigma y sepas aprovecharlo.

Sobreescribiendo los métodos get y set

Por supuesto podemos definir nuestros propios métodos gets y sets que sobrescriben a los que están por defectos o inferidos por el compilador de Kotlin:

class Persona {
var nombre: String = ""
    get() = field
    set(value) {
      field = value
    }
var apellido: String = ""
var edad: Int = 0
}

Constructores de las clases en Kotlin

Constructor principal

Como todo lenguaje de programación orientado a objetos, Kotlin cuenta con métodos constructores en las clases que sirven para inicializar valores de la clase, al igual que en Java; pero a diferencia de este último, Kotlin incorpora una forma muy interesante con la cual ahorramos unas líneas de código cambia la metodología y no define el constructor principal como un método dentro de la función si no embebido dentro de la clase:

class Persona(nombre: String, apellido: String, edad: Int) {
var nombre: String = nombre
var apellido: String = apellido
var edad: Int = edad
}

Kotlin define el constructor principal como parte de la clase en la cabecera/header de la misma, en donde los parámetros son opcionales

Ya con esto, de manera automática Koltin hace la equivalencia entre los parámetros en el constructor con las propiedades definidas en la clase.

Para crear una instancia inicializando desde el constructor tenemos: var persona = Persona("Andrés", "Cruz", 27)    

Para entender este último comentario, podríamos definir el método constructor de la siguiente manera:

class Persona(nombre: String, apellido: String, edad: Int) {
var nombre: String = ""
var apellido: String = ""
var edad: Int = 0

init {
	this.nombre = nombre
	this.apellido = apellido
	this.edad = edad
}

}

Este último código sería "la manera Java" en la que especificamos qué parámetros del constructor inicializan las propiedades de la clase, internamente, esto es lo que hace Kotlin con la estructura del init{}.

O podríamos simplificarlo aún más:

    class Persona(nombre: String, apellido: String, edad: Int) {
    var nombre: String = nombre
    var apellido: String = apellido
    var edad: Int = edad

    }

Y con esto eliminamos la estructura del init de nuestro código.

También podemos colocar la palabra constructor luego de indicar el nombre de la clase:

class Persona constructor (nombre: String, apellido: String, edad: Int) { var nombre: String = nombre var apellido: String = apellido var edad: Int = edad }

Todo estos ejemplos de constructores principales son equivalentes, pero si no vamos a realizar ninguna validación podemos dejarlo empleando el constructor por defecto:

class Persona(nombre: String, apellido: String, edad: Int) { var nombre: String = "" var apellido: String = "" var edad: Int = 0 }

Instanciando la clase anterior

Independientemente el esquema que prefieras, para crear una instancia de la clase persona empleando el constructor, podemos hacer lo siguiente:

var persona = Persona("Andrés"," Cruz",27)

Múltiples constructores (constructores secundarios)

Teniendo como constructor principal el que define (nombre: String, apellido: String, edad: Int) también definimos un constructor secundario, los cuales se encuentran definidos fuera del header de la clase pero dentro del cuerpo de la clase como para este ejemplo constructor (nombre: String, apellido: String):

class Persona constructor (nombre: String, apellido: String, edad: Int) {
var nombre: String = ""
var apellido: String = ""
var edad: Int = 0

constructor (nombre: String, apellido: String) : this(nombre, apellido, 0)

}

De esta manera, puedes definir cuántos constructores secundarios desees.

O lo que es lo mismo:

class Persona (nombre: String, apellido: String, edad: Int) {
var nombre: String = nombre
var apellido: String = apellido
var edad: Int = edad

constructor (nombre: String, apellido: String) : this(nombre, apellido, 0)

}

Como podemos ver, existen múltiples combinaciones según nuestro esquema preferido; en la siguiente entrada veremos los tipos de clases en Kotlin, herencia, interfaces y clases abstractas en Kotlin.


Andrés Cruz
Desarrollo con Laravel, Django, Flask, CodeIgniter, HTML5, CSS3, MySQL, JavaScript, Vue, Android, iOS, Flutter

Andrés Cruz en Udemy

Acepto recibir anuncios de interes sobre este Blog.

Conozca nuestros cursos sobre Laravel, CodeIgniter, Flutter, Electron, Django, Flask y muchos más!

Ver los cursos
¡Hazte afiliado en Gumroad!

!Cursos desde!

4$

En Academia

Ver los cursos

!Libros desde!

1$

Ver los libros
!Web Alojada en Hostinger!