Android Academy · Lección

Constructores e init

Cree e inicialice objetos

Constructores e init es una lección gratuita de Android Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Android Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Android Academy incluye 4 lecciones en total.

¿Qué es un constructor?

Un constructor es un código especial que se ejecuta al crear un objeto. Establece los valores iniciales del objeto.

En Kotlin, el constructor principal se escribe justo al lado del nombre de la clase.

El constructor principal

El constructor principal va entre paréntesis después del nombre de la clase. Los valores se pasan al crear el objeto.

Aquí, Dog requiere un nombre al construirse.

class Dog(name: String) {
    val dogName = name
}

fun main() {
    val d = Dog("Rex")
    println(d.dogName)
}

Propiedades en el constructor

Al añadir val o var delante de un parámetro del constructor, este se convierte automáticamente en una propiedad.

Este es el estilo de Kotlin más habitual y conciso.

class Dog(val name: String, var age: Int)

fun main() {
    val d = Dog("Rex", 3)
    println(d.name + " is " + d.age)
}

Valores predeterminados del constructor

Los parámetros del constructor también pueden tener valores predeterminados. Así, quien realice la llamada puede omitirlos.

Aquí, age toma el valor predeterminado 0 si no se proporciona.

class Dog(val name: String, var age: Int = 0)

fun main() {
    val d = Dog("Max")
    println(d.age)
}

El bloque init

Un bloque init se ejecuta como parte del constructor principal. Úselo para la lógica de configuración que no cabe en una sola línea de propiedad.

Puede leer los parámetros del constructor.

class Dog(val name: String) {
    init {
        println("Created dog: " + name)
    }
}

fun main() {
    Dog("Rex")
}

Validar en init

Un uso habitual de init es comprobar las entradas. Aquí evitamos una edad negativa mediante require.

Si la comprobación falla, el objeto nunca se crea.

class Person(val age: Int) {
    init {
        require(age >= 0) { "Age cannot be negative" }
    }
}

fun main() {
    val p = Person(25)
    println(p.age)
}

Orden de ejecución

Los inicializadores de propiedades y los bloques init se ejecutan de arriba abajo, en el orden en que aparecen en la clase.

Esto es importante cuando una línea depende de un valor establecido anteriormente.

class Demo {
    val a = 1
    init { println("a is " + a) }
    val b = a + 1
    init { println("b is " + b) }
}

fun main() {
    Demo()
}

Propiedades calculadas

Puede calcular una propiedad a partir de los valores del constructor dentro del cuerpo de la clase.

Aquí, area se deriva de width y height.

class Rect(val width: Int, val height: Int) {
    val area = width * height
}

fun main() {
    println(Rect(3, 4).area)
}

Constructores secundarios

Una clase también puede tener constructores secundarios mediante la palabra clave constructor. Deben delegar en el principal con this(...).

Son menos habituales porque los valores predeterminados suelen ser suficientes.

class Dog(val name: String) {
    constructor() : this("Unknown")
}

fun main() {
    println(Dog().name)
}

Usar el objeto nuevo

Cuando el constructor y init terminan de ejecutarse, el objeto está listo para usarse. Puede leer sus propiedades y llamar a sus métodos inmediatamente.

Aquí, el constructor configura un saldo y un método descuenta una cantidad de él.

class Account(var balance: Int) {
    fun spend(amount: Int) {
        balance = balance - amount
    }
}

fun main() {
    val acc = Account(100)
    acc.spend(30)
    println(acc.balance)
}

Los constructores preparan el terreno

Los constructores y los bloques init garantizan que cada objeto comience en un estado válido.

Constructor principal: declara y recibe valores.
init: ejecuta la configuración y la validación.

Esto evita que haya objetos a medio construir en su aplicación.

Comprobación rápida

Compruebe lo que ha aprendido sobre los constructores y init.

Resumen

Ha aprendido a usar el constructor principal, a declarar propiedades con val/var en él y a asignarles valores predeterminados.

El bloque init se encarga de la configuración y la validación, y se ejecuta de arriba abajo junto con los inicializadores de propiedades. A continuación, conocerá las data classes, que generan este código repetitivo automáticamente.

Preguntas frecuentes

¿La lección «Constructores e init» es gratis?

Sí — el texto completo de «Constructores e init» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Android Academy, actualiza a CoddyKit PRO. El curso de Android Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Constructores e init»?

Cree e inicialice objetos Practicas Android Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Android Academy?

No se requiere experiencia previa. Android Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Constructores e init»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Android Academy?

Sí. Cada lección de Android Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Android Academy