Kotlin Desde Cero: Tipos Básicos, Variables y Arreglos

kotlin
Vistas: 9
0 0
Tiempo de Lectura:10 Minuto(s), 5 Segundo(s)

Bienvenidos a esta entrada donde explicaremos los puntos mas básicos para comenzar a desarrollar en Kotlin por eso veremos Kotlin Desde Cero: Tipos Básicos, Variables y Arreglos.

Pero… Antes que nada posiblemente te preguntes que es Kotlin?, pues en la web de desarrolladores de Android dice:

Kotlin es un lenguaje de programación estático de código abierto que admite la programación funcional y orientada a objetos. Proporciona una sintaxis y conceptos similares a los de otros lenguajes, como C#, Java y Scala, entre muchos otros. No pretende ser único, sino que se inspira en décadas de desarrollo del lenguaje. Cuenta con variantes que se orientan a la JVM (Kotlin/JVM), JavaScript (Kotlin/JS) y el código nativo (Kotlin/Native).

Kotlin es administrado por Kotlin Foundation, un grupo creado por JetBrains y Google, que se ocupa de continuar el desarrollo del lenguaje. Google admite oficialmente Kotlin para el desarrollo de Android, lo cual significa que la documentación y las herramientas de Android están diseñadas para ser compatibles con Kotlin.

Desarrolladores de Android https://developer.android.com/kotlin/overview?hl=es

En resumen

Kotlin es un lenguaje de programación moderno que compila a código Java. Es gratuito, de código abierto, y permite que el codificar para Android incluso más divertido.

Kotlin es 100% interoperable con Java. En otras palabras, puede ser usado junto con Java en el mismo proyecto. Así que puedes refactorizar partes de tu código Java a Kotlin y no se romperá. En adición a eso, es conciso, expresivo, y tiene gran estampación. Kotlin puede ser usado en el back-end (lado del servidor), pero está teniendo mucha atención justo ahora como un lenguaje para desarrollo de aplicaciones Android. Kotlin es ahora soportado por Google como lenguaje de primera clase para desarrollo Android, ¡así que la popularidad de Kotlin está por explotar!

Variables

En Kotlin, usa las palabras clave val para declarar una constante o var para declarar una variable. Puedes especificar un tipo tal como String o Int después del nombre de la variable. En el ejemplo de abajo, declaramos una constante firstName de tipo String con la palabra clave val.

val nombre: String = "Alex"

Pero pronto te darás cuenta de que en Kotlin, es frecuentemente posible omitir el tipo de la declaración y el compilador no se quejará.

val apellido= "Ramirez" // seguira compilando

En el código de arriba, observarás que no declaramos de manera explícita el tipo String. El código de arriba aún funcionará porque el compilador ha inferido de manera implícita el tipo usando interfaz tipo.

La diferencia entre las palabras clave val y var es que el primero es inmutable o de solo lectura (su valor no puede ser cambiado), mientras que el último es mutable (su valor puede ser cambiado).

val cumple = "7 Enero, 1991"
cumple = "7 Enero, 1991" // no se puede cambiar
 
var car = "Saburu Impreza"
car = "Saburu Impreza" // si se puede cambiar

Nota que para una variable declarada con la palabra clave var la cuál tiene su tipo inferido por el compilador, asignar otro valor a un tipo diferente no funcionará. En otras palabras, el valor de la variable puede cambiar, ¡pero su tipo no! Por ejemplo:

var edad = 30
edad= "30 años de edad" // Error: no coinciden los tipos

Es altamente recomendable que comiences haciendo tus variables inmutables declarándolas con la palabra clave val, de modo que no mantenga demasiados estados. Esto hace a tu código más seguro para procesamiento múltiple, porque asegura que tus variables no pueden ser modificadas por otros hilos de manera inesperada.

Otra cosa que deberías saber sobre la palabra clave val es que puedes declararla con solo un tipo y asignarle un valor después. Pero aún puedes asignar solo un valor una vez.

val nombreCarro: String
nombreCarro = "Saburu Impreza" // se puede compilar

En Java, es posible declarar múltiples variables del mismo tipo en una sola línea, pero esto no funcionará en Kotlin. En Kotlin, todas las declaraciones de variable deben estar en sus propias líneas.

val nombreCarro = "BMW", nombreCalle = "Las Flores" // esto no puede ser compilado
 
// esto si se puede compilar
var nombre Carro = "BMW"
var nombreCalle = "Las Flores"

Interfaz Tipo o Deducción

Kotlin es un lenguaje fuertemente tipado que soporta interfaz tipo o deducción. Este es el mecanismo empleado por el compilador para averiguar tipo desde contexto. Java no tiene un mecanismo de interfaz tipo, lo que significa que debes declarar explícitamente el tipo de cada función o variable. La interfaz tipo ayuda a reducir el código que tienes que escribir.

val pais = "México"// El compilador deduce el tipo
val = 234

El código de arriba compilaría incluso aunque no declaramos de manera explícita el tipo para la variable país. El compilador es lo suficientemente inteligente para saber que el país es de tipo String, porque el valor, “México”, es una cadena de texto.

Tipos Básicos

En Java, tenemos dos tipos de tipo—primitivo (ej. int, long, boolean, byte, char, etc.) y tipos de referencia (ej. array, String). Java usa envoltorios (como java.lang.Integer) para hacer que los tipos primitivos se comporten como objetos. Pero en Kotlin, no hay tal distinción. En su lugar, todos los tipos son objetos.

Números

Los tipos enteros disponibles en Kotlin son:

  • Long—64 bit
  • Int—32 bit
  • Short—16 bit
  • Byte—8 bit

Los tipos de punto flotante son:

  • Double—64 bit
  • Float—32 bit
val myInt = 55
val myLong = 40L
val myFloat = 34.43F
val myDouble = 45.78
val myHexadecimal = 0x0F
val myBinary = 0b010101

Puedes observar que creamos un literal Long agregando el sufijo L, y para Float agregamos el sufijo F o f. Los números también pueden ser escritos en notación hexadecimal usando el prefijo 0x o 0X y en binario usando el prefijo 0b o 0B. Nota que en todos estos casos, Kotlin puede usar interfaz tipo para saber el tipo que queremos en su lugar.

val myLong = 19L
val myLongAgain: Long = 40

Para convertir un número desde un tipo a otro, tienes que llamar de manera explícita la función de conversión correspondiente. En otras palabras, no hay conversión implícita entre tipos de números.

val myNumber = 400
val myNumberAgain: Long = myNumber // Error: no coinciden los tipos

Cada tipo de número tiene funciones de ayuda que convierten de un tipo de número a otro: toByte()toInt()toLong()toFloat()toDouble()toChar()toShort().

val myInt = 987
val myLong = myInt.toLong()

En el código de arriba, estamos convirtiendo desde un entero a un long. También podemos hacer lo inverso usando el método toInt() en la variable long. Nota que esto truncará el valor para encajar el tamaño más pequeño en un tipo Int si es necesario—¡así que ten cuidado cuando conviertas desde tipos más grandes a más pequeños!

También puedes convertir un String en un tipo número

val stringNumber = "101"
val intValue = stringNumber.toInt()

En el código de arriba, convertimos la variable stringNumber a un tipo Int llamando al método toInt() en la variable. Podemos escribir esto de manera mas concisa, llamando en su lugar el método directamente sobre la cadena:

val intValue = "101".toInt()

A Tipo Booleano

El tipo Boolean en Kotlin es el mismo que en Java. Su valor puede ser verdadero o falso. Los operadores disyunción (||), conjunción (&&), y negación (!) pueden ser ejecutados sobre tipos booleanos, justo como Java.

val myTrueBoolean = true
val myFalseBoolean = false
 
val x = 1
val y = 3
val w = 4
val z = 6
 
val n = x < z && z > w // n is true

Cadenas

Las cadenas pueden ser creadas ya sea con comillas dobles o comillas triples. Adicional a es, los caracteres de escape pueden ser usados con comillas dobles.

val multipleStringLines = """
        This is first line
        This is second line
        This is third line """

Kotlin también soporta interpolación de cadena o plantillas de cadena. Esta es una manera más sencilla de construir cadenas dinámicas que concatenación, que es lo que usamos en Java. Usando plantillas de cadena, podemos insertar variables y expresiones en una cadena.

val cantidadEnCuenta = 200
val mensajeBanco = "Tu saldo en tu cuenta es de $cantidadEnCuenta" // Tu saldo es de 200

En el código de arriba, creamos una cadena literal, y dentro de esta, referimos a una variable por el uso de un caracter $ en frente del nombre de la variable. Nota que si la variable no es correcta o no existe, el código no se compilará.

¿Qué si necesitas usar $ en tu cadena? ¡Solo lo escapas con \$! También, puedes llamar métodos desde un String interpolado directamente; tienes que agregar llaves ${} para envolverlo.

val nombre = "Alex"
val mensaje = "La Primera letra de mi nombre es ${nombre.first()}" // La primera letra de mi nombre es A

Otra cosa genial que puedes hacer es ejecutar alguna lógica dentro de las llaves cuando creas un literal String.

val edad = 30
val otroMensaje = "Tu eres ${if (age > 18) "Mayor de Edad" else "Menor de Edad"}"// Tu eres Mayor de Edad

Arreglos

En Kotlin, hay dos maneras principales de crear un arreglo: usando la función de ayuda arrayOf() o el constructor Array().

La Función arrayOf()

Por ejemplo, creemos un arreglo con algunos elementos usando arrayOf().

val myArray = arrayOf(4, 5, 7, 3)

Ahora, para acceder a cualquiera del elemento, podemos usar su índice: myArray[2]. nota que podemos pasar valores de diferentes tipos en el arrayOf() como argumentos y aún funcionará—será un arreglo de tipo mixto.

val myArray = arrayOf(4, 5, 7, 3, "Alex", false)

Para hacer cumplir que todos los valores del arreglo tienen el mismo tipo, ej. Int, declaramos un tipo llamando arrayOf<Int>() o intArrayOf().

val myArray3 = arrayOf<Int>(4, 5, 7, 3, "Chike", false) // no se compilara
val myArray4 = intArrayOf(4, 5, 7, 3, "Chike", false)  // tampoco se compilara

También tenemos otras funciones de utilidad para crear arreglos de otros tipos tales como charArrayOf()booleanArrayOf()longArrayOf()shortArrayOf()byteArrayOf(), y así por el estilo. Detrás de escenas, usar estas funciones creará un arreglo de sus respectivos tipos primitivos Java. En otras palabras, intArrayOf() compilará al tipo primitivo regular Java int[]byteArrayOf() será byte[]longArrayOf() será long[], y así por el estilo.

El Constructor Array()

Ahora veamos cómo crear un arreglo con Array(). El constructor de esta clase requiere un tamaño y una función lambda. Aprenderemos más sobre funciones lambda después en esta serie, pero por ahora, solo entiende que es una manera simple en línea de declarar una función anónima. En este caso, el trabajo de la función lambda es inicializar el arreglo con elementos.

val numerosArray = Array(5, { i -> i * 2 })

En el código de arriba, pasamos 5 como el tamaño del arreglo en el primer argumento. El segundo argumento toma una función lambda, la cuál toma el índice del elemento del arreglo y después devuelve el valor para ser insertado en ese índice en el arreglo. Así que en el ejemplo de arriba, creamos un arreglo con elementos 0, 2, 4, 6, y 8.

Comentarios

Este es uno fácil. En Kotlin, los comentarios son los mismos que en Java- Podemos usar ya sea comentarios de bloque o de línea:

/*
hola, soy un bloque de comentario
y puede tener varias lineas,
aqui esta otra
y otra
*/
 
// yo soy un comentario de una sola linea

Conclusión

En este tutorial, aprendiste los básicos del lenguaje de programación Kotlin: variables, tipos básicos, interfaces de tipo, arreglos y comentarios. En el siguiente tutorial en la serie Kotlin Desde Cero, aprenderás sobre ciclos, rangos, condiciones, colecciones y paquetes en Kotlin. ¡Hasta pronto!

Para aprender más sobre el lenguaje Kotlin, recomiendo visitar la documentación Kotlin.

Te puede Interesar: Revive Fotografías Antiguas con IA – MyCodes4You

Happy
Happy
0 %
Sad
Sad
0 %
Excited
Excited
0 %
Sleepy
Sleepy
0 %
Angry
Angry
0 %
Surprise
Surprise
0 %
Previous post Revive Fotografías Antiguas con IA
kotlin Next post Kotlin desde cero: nulabilidad, bucles y condiciones
Social profiles