Constructor primario y parámetros de propiedades
Declare clases con constructores primarios y declaraciones de propiedades en línea.
Constructor primario y parámetros de propiedades es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 1 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 Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.
El constructor primario
Una clase de Kotlin declara su constructor primario justo después del nombre de la clase, entre paréntesis. No hay cuerpo de método, solo una lista de parámetros.
La clase más sencilla
El constructor primario sin modificadores no se muestra después del nombre de la clase.
class Greeter(val name: String) {
fun greet() = "Hello, $name!"
}
fun main() {
println(Greeter("Ada").greet())
}Parámetros de propiedades
Anteponer val o var a un parámetro del constructor lo convierte en una propiedad de la clase en un solo paso.
class Person(val name: String, var age: Int)
fun main() {
val p = Person("Bob", 30)
println("${p.name} is ${p.age}")
p.age = 31
println("Now ${p.age}")
}Parámetros sin val/var
Los parámetros del constructor sin val/var son locales al constructor: se pueden usar en bloques init o inicializadores de propiedades, pero no se pueden consultar posteriormente.
class Logger(prefix: String) {
val msg = "$prefix: ready"
}
fun main() {
val l = Logger("[INFO]")
println(l.msg)
// l.prefix // ERROR — not a property
}Valores predeterminados de parámetros
Proporcione valores predeterminados para los parámetros del constructor y evite el código repetitivo de las sobrecargas.
class User(
val name: String,
val age: Int = 0,
val email: String = ""
)
fun main() {
println(User("Ana").age) // 0
println(User("Ben", 25).email) // ""
println(User("Cal", 30, "c@x.io").email)
}Argumentos con nombre
Omita el orden posicional y asigne nombres a los parámetros en el punto de llamada, especialmente útil cuando hay valores predeterminados.
class HttpClient(
val baseUrl: String,
val timeoutMs: Int = 5000,
val retries: Int = 3
)
fun main() {
val c = HttpClient(
baseUrl = "https://api.example.com",
retries = 5
)
println("retries=${c.retries} timeout=${c.timeoutMs}")
}Visibilidad del constructor
Use private constructor para impedir la creación de instancias externas, algo habitual cuando se combina con métodos de fábrica.
class Singleton private constructor() {
companion object {
val instance = Singleton()
}
}
fun main() {
val s = Singleton.instance
println(s)
}Constructores secundarios
Añada constructores adicionales con la palabra clave constructor. Deben delegar en el constructor primario mediante this(...).
class Point(val x: Int, val y: Int) {
constructor(value: Int) : this(value, value)
}
fun main() {
println("${Point(3).x}, ${Point(3).y}") // 3, 3
}Constructor con visibilidad
Puede combinar distintos niveles de visibilidad para cada constructor, algo útil en las bibliotecas.
class Lib internal constructor(val key: String) {
companion object {
fun create(key: String) = Lib(key)
}
}
fun main() {
println(Lib.create("abc").key)
}Resumen del bloque init
El código que deba ejecutarse durante la construcción se coloca en un bloque init { }. Los bloques init múltiples se ejecutan en el orden en que aparecen en el código fuente.
class Validator(val value: String) {
init { require(value.isNotBlank()) { "value cannot be blank" } }
}
fun main() {
println(Validator("ok").value)
// Validator("") // throws IllegalArgumentException
}Combinar propiedades y lógica
Las declaraciones de propiedades, los constructores secundarios y los bloques init se combinan para formar un pipeline de inicialización flexible.
class Account(
val owner: String,
initialBalance: Double = 0.0
) {
var balance: Double = initialBalance
private set
init {
require(initialBalance >= 0) { "balance must be non-negative" }
}
fun deposit(amount: Double) { balance += amount }
}
fun main() {
val a = Account("Alice", 100.0)
a.deposit(50.0)
println("${a.owner}: ${a.balance}") // Alice: 150.0
}Comprobación rápida
¿Qué hace la palabra clave val cuando se utiliza en un parámetro del constructor primario?
Resumen
El constructor primario se encuentra en la cabecera de la clase. Use val/var para los parámetros que sean propiedades; los parámetros sin modificadores son locales al constructor. Añada valores predeterminados para reducir las sobrecargas y ejecute la lógica de configuración en bloques init. Los constructores secundarios delegan mediante this(...).
Preguntas frecuentes
¿La lección «Constructor primario y parámetros de propiedades» es gratis?
Sí — el texto completo de «Constructor primario y parámetros de propiedades» 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 Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Constructor primario y parámetros de propiedades»?
Declare clases con constructores primarios y declaraciones de propiedades en línea. Practicas Kotlin 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 Kotlin Academy?
No se requiere experiencia previa. Kotlin 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 1 de 4.
¿Cuánto tiempo toma la lección «Constructor primario y parámetros de propiedades»?
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 Kotlin Academy?
Sí. Cada lección de Kotlin 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
- Constructor primario y parámetros de propiedades
- Bloques init y orden de inicialización
- Getters y setters personalizados con field
- lateinit e inicialización diferida