Un constructor es una función miembro especial que se invoca cuando se crea un objeto de la clase principalmente para inicializar variables o propiedades. Una clase debe tener un constructor y, si no declaramos un constructor, el compilador genera un constructor predeterminado.
Kotlin tiene dos tipos de constructores:
- Constructor principal
- Constructor secundario
Una clase en Kotlin puede tener como máximo un constructor principal y uno o más constructores secundarios. El constructor primario inicializa la clase, mientras que el constructor secundario se usa para inicializar la clase e introducir algo de lógica adicional.
Constructor primario –
El constructor primario se inicializa en el encabezado de la clase, va después del nombre de la clase, usando la palabra clave constructor . Los parámetros son opcionales en el constructor principal.
class Add constructor(val a: Int, val b: Int) {
// code
}
La palabra clave constructor se puede omitir si no se especifican anotaciones ni modificadores de acceso.
class Add(val a: Int, val b: Int) {
// code
}
Programa Kotlin del constructor principal –
Java
//main function
fun main(args: Array<String>)
{
val add = Add(5, 6)
println("The Sum of numbers 5 and 6 is: ${add.c}")
}
//primary constructor
class Add constructor(a: Int,b:Int)
{
var c = a+b;
}
Producción:
The Sum of two numbers is: 11
Explicación: cuando creamos el objeto agregado para la clase, los valores 5 y 6 pasan al constructor. Los parámetros del constructor a y b se inicializan con los parámetros 5 y 6 respectivamente.
La variable local c contiene la suma de variables. En general, accedemos a la propiedad del constructor usando ${add.c} .
Constructor primario con bloque inicializador –
El constructor principal no puede contener ningún código, el código de inicialización se puede colocar en un bloque inicializador separado con el prefijo de la palabra clave init .
Programa Kotlin del constructor principal con bloque inicializador –
¿Qué es el bloque de inicio?
Actúa como un bloque inicializador donde se inicializan las variables miembro. Este bloque se ejecuta cada vez que se crea una instancia de esta clase.
Puede haber varios bloques de inicio y se llaman en el orden en que están escritos dentro de la clase.
Nota: se llama a los bloques de inicio antes de llamar al constructor de esta clase.
Kotlin
fun main(args: Array<String>) {
val person = Person("Mahmood")
}
class Person {
constructor(name : String){
println("This is primary constructor")
}
init{
println("This is first init block")
}
init{
println("This is second init block")
}
init{
println("This is third init block")
}
}
Producción:
This is first init block This is second init block This is third init block This is primary constructor
Explicación: cuando se crea el objeto persona para la clase Persona, el valor «Mahmood» se pasa al nombre de parámetros del constructor. Se declaran dos propiedades en el id y el nombre de la clase.
El bloque de inicialización se ejecuta en el momento de la creación del objeto y no solo inicializa las propiedades, sino que también se imprime en la salida estándar.
Valor predeterminado en el constructor principal:
De manera similar a los valores predeterminados de las funciones en las funciones, podemos inicializar los parámetros del constructor con algunos valores predeterminados.
Programa Kotlin de valores predeterminados en el constructor principal –
Java
fun main(args: Array<String>) {
val emp = employee(18018, "Sagnik")
// default value for emp_name will be used here
val emp2 = employee(11011)
// default values for both parameters because no arguments passed
val emp3 = employee()
}
class employee(emp_id : Int = 100 , emp_name: String = "abc") {
val id: Int
var name: String
// initializer block
init {
id = emp_id
name = emp_name
print("Employee id is: $id, ")
println("Employee name: $name")
println()
}
}
Producción:
Employee id is: 18018, Employee name: Sagnik Employee id is: 11011, Employee name: abc Employee id is: 100, Employee name: abc
Explicación: aquí hemos inicializado los parámetros del constructor con algunos valores predeterminados emp_id = 100 y emp_name = “abc”.
Cuando se crea el objeto emp , pasamos los valores de ambos parámetros para que imprima esos valores.
Pero, en el momento de la creación del objeto emp2 , no hemos pasado emp_name, por lo que el bloque inicializador usa los valores predeterminados e imprime en la salida estándar.
Constructor Secundario –
Como se mencionó anteriormente, Kotlin puede tener uno o más constructores secundarios. Los constructores secundarios permiten la inicialización de variables y también permiten proporcionar algo de lógica a la clase. Están precedidos por la palabra clave constructor .
Programa Kotlin de implementación de constructor secundario-
Java
//main function
fun main(args: Array<String>)
{
Add(5, 6)
}
//class with one secondary constructor
class Add
{
constructor(a: Int, b:Int)
{
var c = a + b
println("The sum of numbers 5 and 6 is: ${c}")
}
}
Producción:
The sum of numbers 5 and 6 is: 11
El compilador decide qué constructor secundario se llamará en función de los argumentos recibidos. En el programa anterior, no especificamos qué constructor y compilador decide invocar por sí mismo.
Programa Kotlin de dos constructores secundarios en una clase.
Java
fun main(args: Array<String>) {
employee(18018, "Sagnik")
employee(11011,"Praveen",600000.5)
}
class employee {
constructor (emp_id : Int, emp_name: String ) {
var id: Int = emp_id
var name: String = emp_name
print("Employee id is: $id, ")
println("Employee name: $name")
println()
}
constructor (emp_id : Int, emp_name: String ,emp_salary : Double) {
var id: Int = emp_id
var name: String = emp_name
var salary : Double = emp_salary
print("Employee id is: $id, ")
print("Employee name: $name, ")
println("Employee name: $salary")
}
}
Producción:
Employee id is: 18018, Employee name: Sagnik Employee id is: 11011, Employee name: Praveen, Employee name: 600000.5
Programa Kotlin de tres constructores secundarios en una clase –
Java
//main function
fun main(args: Array<String>)
{
Add(5, 6)
Add(5, 6, 7)
Add(5, 6, 7, 8)
}
//class with three secondary constructors
class Add
{
constructor(a: Int, b: Int)
{
var c = a + b
println("Sum of 5, 6 = ${c}")
}
constructor(a: Int, b: Int, c: Int)
{
var d = a + b + c
println("Sum of 5, 6, 7 = ${d}")
}
constructor(a: Int, b: Int, c: Int, d: Int)
{
var e = a + b + c + d
println("Sum of 5, 6, 7, 8 = ${e}")
}
}
Producción:
Sum of 5, 6 = 11 Sum of 5, 6, 7 = 18 Sum of 5, 6, 7, 8 = 26
Llamar a un constructor secundario desde otro:
Un constructor secundario puede llamar a otro constructor secundario de la misma clase usando esta función(). En el siguiente programa, hemos llamado a otro constructor usando this(a,b,7) porque la invocación de ese constructor requiere tres parámetros.
Programa Kotlin de llamar a un constructor desde otro-
Java
//main function
fun main(args: Array<String>)
{
Add(5,6)
}
class Add {
// calling another secondary using this
constructor(a: Int,b:Int) : this(a,b,7) {
var sumOfTwo = a + b
println("The sum of two numbers 5 and 6 is: $sumOfTwo")
}
// this executes first
constructor(a: Int, b: Int,c: Int) {
var sumOfThree = a + b + c
println("The sum of three numbers 5,6 and 7 is: $sumOfThree")
}
}
Producción:
The sum of three numbers 5,6 and 7 is: 18 The sum of two numbers 5 and 6 is: 11
Llamar al constructor secundario de la clase principal desde el constructor secundario de la clase secundaria:
Podemos llamar al constructor secundario de la clase principal desde la clase secundaria usando la palabra clave super . En el siguiente programa, hemos mostrado el proceso de llamada.
Java
fun main(args: Array<String>) {
Child(18018, "Sagnik")
}
open class Parent {
constructor (emp_id: Int, emp_name: String, emp_salary: Double) {
var id: Int = emp_id
var name: String = emp_name
var salary : Double = emp_salary
println("Employee id is: $id")
println("Employee name: $name")
println("Employee salary: $salary")
println()
}
}
class Child : Parent {
constructor (emp_id : Int, emp_name: String):super(emp_id,emp_name,500000.55){
var id: Int = emp_id
var name: String = emp_name
println("Employee id is: $id")
println("Employee name: $name")
}
}
Producción:
Employee id is: 18018 Employee name: Sagnik Employee salary: 500000.55 Employee id is: 18018 Employee name: Sagnik
Publicación traducida automáticamente
Artículo escrito por SagnikMazumder y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA