Crear constantes en Kotlin

1. Usar constantes de clase en Kotlin
2. Usar un Singleton en Kotlin
3. Usar constantes de nivel superior en Kotlin
4. Use un archivo separado que contenga constantes en Kotlin
5. Conclusión

Se utiliza una constante para almacenar datos cuyos valores siempre se conocen y los datos no cambian durante la ejecución del programa. Las constantes se diferencian de las variables en que las variables pueden cambiar los datos durante la ejecución del programa.

Por ejemplo, supongamos que está desarrollando un simulador de motos. Las diferentes propiedades de la moto nunca cambiarán durante toda su vida, como el número de ruedas.

Para asegurarnos de que el número de ruedas no cambia, declaramos una constante en la aplicación y la asignamos al número de ruedas que puede tener una moto. Usamos constantes para evitar errores en la entrada del usuario, como proporcionar cuatro ruedas para una motocicleta en lugar de dos.

En este tutorial, aprenderemos cómo crear constantes en Kotlin, la convención de nomenclatura utilizada y cómo incluirlas en su aplicación.

Usar constantes de clase en Kotlin

Vaya a IntelliJ y seleccione Archivo > Nuevo > Proyecto para crear un nuevo proyecto de Kotlin. Ingrese kotlinConstants como el nombre del proyecto o cualquier nombre que prefiera.

Seleccione Kotlin en la sección Idioma e Intellij en la sección Sistema de compilación. Pulse el botón Crear para crear el proyecto.

Cree la estructura de carpetas com/constants en la carpeta kotlin. Cree un archivo Main.kt en la carpeta constants y copie y pegue el siguiente código en el archivo.

package com.constants

class Car(private val name: String){
    /**
     * This is a constant that is only used
     * inside this class
     */
    private val numberOfWheels = 4
    /**
     * The companion object defines a constant
     * that exists only as a single copy and
     * Can also be used outside the class
     */
    companion object{
        const val NUMBER_OF_WHEELS = 4
    }
    fun showMessage(): String{
        return "A ${this.name} has ${this.numberOfWheels} wheels"
    }

}
fun main() {
    val nissan = Car("Nissan");
    println(nissan.showMessage());
    println("Number of wheels = ${Car.NUMBER_OF_WHEELS}");
}

Hemos declarado dos constantes dentro de la clase Car; la primera constante declarada usando la palabra clave private solo debe usarse en esta clase y no se puede acceder desde fuera de la clase.

En cuanto a la convención de nomenclatura, hemos usado la convención de nomenclatura camel case ya que solo se usa dentro de la clase.

La segunda constante se declara dentro de un objeto complementario en la clase. Un objeto complementario se usa para declarar constantes y funciones que pertenecen a esta clase, lo que significa que no se puede crear una instancia usando los objetos de la clase.

Estas constantes son similares a los campos y métodos estáticos en Java. Para invocar las constantes, generalmente usamos la clase porque solo existe una copia de las constantes.

Se puede acceder a las constantes declaradas dentro de un objeto complementario desde fuera de la clase, y la convención de nomenclatura utilizada para estas constantes es una combinación de letras mayúsculas y guiones bajos.

El método main invoca Car() para crear un nuevo objeto Car. El método showMessage() utiliza la constante utilizada dentro de la clase para registrar un mensaje que contiene el valor en la consola.

El último mensaje println() registra el valor de la constante declarada utilizando un objeto complementario. Ejecute el código para verificar que el programa genera lo siguiente.

Producción :

A Nissan has 4 wheels
Number of wheels = 4

Usar un Singleton en Kotlin

Singleton es un patrón de diseño en programación, especialmente en lenguajes de alto nivel. El patrón de diseño singleton se usa cuando tenemos recursos que deben compartirse en la aplicación y en situaciones en las que es costoso crear los recursos.

Tenga en cuenta que cuando usa un singleton, solo se creará una instancia durante toda la vida útil de la aplicación.

Comente el código anterior y copie y pegue el siguiente código en el archivo Main.kt después del comentario.

package com.constants

object Configuration{
    const val USERNAME = "john"
    const val PASSWORD = "1234"
}

fun userLogin(user: String, pass: String): String{
    return "$user logged in with password $pass"
}

fun main() {
    println(userLogin(Configuration.USERNAME,
        Configuration.PASSWORD));
}

En este ejemplo, hemos creado un singleton utilizando la palabra clave object. Utilice siempre esta sintaxis cuando desee crear un singleton en Kotlin.

Detrás de escena, el compilador hace que el constructor sea privado, crea una referencia de nuestra Configuración y la inicializa en un bloque estático. El singleton solo se inicializará una vez que accedamos por primera vez a cualquier campo estático.

El userLogin() es un método personalizado que hemos definido para consumir las propiedades de singleton. Para acceder a los valores, invocamos el nombre del singleton seguido del nombre de la propiedad.

Esto es similar a lo que hicimos con las constantes declaradas en un objeto complementario, pero este enfoque requiere menos recursos. Ejecute el código y verifique que el programa genere lo siguiente.

Producción :

john logged in with password 1234

Usar constantes de nivel superior en Kotlin

Comente el código anterior y copie y pegue el siguiente código en el archivo Main.kt después del comentario.

package com.constants

const val CONNECTION_POOL = 10

class DBDriver{
   companion object{
       fun isConnectionExceeded(value: Int): Boolean{
           return (value > CONNECTION_POOL)
       }
   }
}

fun main() {
    println(DBDriver.isConnectionExceeded(11));
}

Las constantes de nivel superior no están encerradas en una función, una clase o una interfaz, lo que significa que puede llamarlas desde fuera de la clase sin crear ningún objeto.

En este ejemplo, hemos declarado una constante de nivel superior llamada CONNECTION_POOL y la consumimos dentro del método isConnectionExceeded() pasando su nombre.

Ejecute el código y observe que el valor constante se lee como de costumbre para realizar los cálculos esperados, como se muestra a continuación.

Producción :

true

Use un archivo separado que contenga constantes en Kotlin

Cree un nuevo paquete llamado consts en la carpeta com. Cree un archivo llamado NetConstants.kt en la carpeta consts, y copie y pegue el siguiente código en el archivo.

package com.consts

const val PORT = 8080
const val PROTOCOL = "DNS"
const val HOST_ADDRESS = "192.168.1.0"

Las constantes definidas en el archivo anterior son similares a las constantes de nivel superior, pero se declaran en un archivo separado con otras partes de la aplicación.

El siguiente ejemplo muestra el uso de constantes en un archivo separado de la misma aplicación. Comente el último ejemplo que cubrimos en el archivo Main.kt, y copie y pegue el siguiente código en el archivo después del comentario.

package com.constants

import com.consts.HOST_ADDRESS
import com.consts.PORT
import com.consts.PROTOCOL

class Server{
   companion object{
       fun connectServer(port: Int, protocol: String, host: String): String{
           return "application connected to " +
                   "$host using port " +
                   "$port through" +
                   " $protocol"
       }
   }
}
fun main() {
    println(Server.connectServer(PORT, PROTOCOL, HOST_ADDRESS));
}

Este ejemplo define el método connectServer() declarado dentro de un objeto complementario de una clase. El método consume las tres constantes que definimos en el archivo NetConstants.kt.

Esto se logra pasando el nombre de la constante al método e importando el nombre de la constante completamente calificada a la clase. La siguiente es la salida de la aplicación después de ejecutarla:

application connected to 192.168.1.0 using port 8080 through DNS

Conclusión

En este tutorial, hemos aprendido las diferentes formas que podemos usar para crear constantes en una aplicación de Kotlin. Los enfoques que hemos aprendido incluyen: usar constantes de clase, singleton y constantes de nivel superior y, finalmente, cubrimos cómo usar constantes declaradas en un archivo separado.