Constructor privado de Kotlin

Podemos definir un constructor primario en programación Java como privado. Entonces podemos acceder al constructor usando un método público estático. Sin embargo, ¿es eso posible en Kotlin?

Kotlin también permite la creación de constructores privados. ¿Cómo? Eso lo veremos en este artículo.

Constructor privado de Kotlin

Los constructores son funciones miembro especiales de una clase de Kotlin. Se invocan cuando creamos e iniciamos un objeto.

Los constructores privados de Kotlin son útiles para habilitar la visibilidad personalizada en la clase; también ocultará el constructor principal de la clase de Kotlin. Por ejemplo, supongamos que queremos evitar la creación de un objeto no deseado para la eficiencia de la memoria. Podemos usar constructores privados para lograr eso.

Podemos definir un constructor de Kotlin como privado usando la palabra clave del modificador de acceso privado y un objeto complementario. Los miembros de la clase pueden acceder a los miembros privados de los objetos complementarios.

La sintaxis para declarar un constructor como privado es:

class class_Name private constructor()

Trabajo de Constructores privados

Los constructores privados funcionan haciendo que el constructor principal de su clase sea privado. Evita que otras clases creen objetos utilizando el constructor private.

Al crear un constructor privado, es mejor utilizar un método estático. La razón es que los métodos estáticos pueden ejecutarse sin inicialización de objetos.

Ahora, los constructores privados permitirán crear e inicializar objetos de la misma clase. Sin embargo, cuando intenta inicializar objetos de otras clases, arrojará un error.

Pros y contras de los constructores privados

Comencemos explorando las ventajas de los constructores privados en Kotlin.

El primer beneficio de usar un constructor privado es la seguridad. Dado que ninguna otra clase puede acceder a los datos de la clase privada, se vuelve segura.

La eficiencia de la memoria también es una ventaja de usar constructores privados, lo que significa que solo se crea una única instancia. Además, también puede evitar la generación automática de un constructor predeterminado.

En cuanto a las desventajas (contras), los constructores privados no permiten la herencia. Además, si queremos inicializar una clase constructora privada, necesitamos usar una clase anidada o un método estático.

Demostración de un constructor privado de Kotlin

Aquí hay un ejemplo en el que usamos la sintaxis anterior para crear una clase con un constructor privado.

import exampleClass.Companion.example

class exampleClass private constructor() {
    companion object {
        fun example() = exampleClass()
    }
}

class exampleClass1: Thread() {
    public override fun run() {
        println("The application is running on ${Thread.currentThread()}")
    }
}

class exampleClass2: Runnable {
    public override fun run() {
        println("Now the application is running on ${Thread.currentThread()}")
    }
}

fun main(){
    val v1 = example()
    println(v1)
    val th1 = exampleClass1()
    th1.start()
    val runnable = exampleClass2()
    val th2 = Thread(runnable)
    th2.start()
}

Producción :

exampleClass@77afea7d
The application is running on Thread[Thread-0,5, main]
Now the application is running on Thread[Thread-1,5, main]