Lenguajes JVM: ahora hablemos de Kotlin

Kotlin es:

• Un lenguaje de programación moderno, conciso y de tipo estático.
•  Diseñado para ser interoperable con Java y funciona en la Máquina Virtual de Java (JVM). 
• Puede compilarse a JavaScript y código nativo, permitiendo su uso en aplicaciones multiplataforma.

Posee características avanzadas como la programación orientada a objetos y funcional, la inferencia de tipos, las expresiones lambda, y la seguridad frente a null (a través de su sistema de tipos).

Fácil de usar, legibilidad y compatibilidad con herramientas y bibliotecas de Java. Actualmente, el lenguaje preferido para el desarrollo de aplicaciones Android.

¿Dónde se usa Kotlin?

1. En desarrollo backend, principalmente con Spring Boot.
2. Desarrollo de aplicaciones para móviles que se ejecutan en dispositivos Android.

¿Cómo compilamos un código escrito en Kotlin?

Un programa en Kotlin tiene la extensión *.kt. Para compilar, crear el JAR y ejecutar debemos seguir éstas instrucciones

# Compilamos y creamos el JAR
kotlinc programa.kt -d programa.jar

# Ejecutamos el JAR
java -jar programa.jar

Nota: Es prefedible usar Maven o Gradle para construir y ejecutar nuestras aplicaciones.

Tipos de datos en Kotlin

Tipos numéricos enteros:

• Byte. 
• Short. 
• Int. 
• Long.

Tipos numéricos decimales:

• Float. 
• Double.

Tipo carácter:

• Char.

Tipo booleano:

• Boolean.

Tipo cadena de texto: 

• String

Tipos espaciales:

• Any. 
• Unit. 
• Nothing. 
• Null.

Colecciones en Kotlin

• List. 
• Set. 
• Map.

Ejercicio 1. Programa que indique si una persona puede votar o no. La edad mínima para votar es de 18 años.

votar.kt

fun main() {
    val edad:Int = 32

    if (edad >= 18) {
        println("Puedes votar.")
    } else {
        println("No puedes votar.")
    }
}

Kotlin y Scala son muy similares. Basta con rehacer el programa a código Scala para darse cuenta.

votar.scala

object votar{
def main(args: Array[String]): Unit = {
        val edad:Int = 32
        if(edad >=18){
           println("Puedes votar.")
        }else{
           println("No puedes votar.")
        }
}

Ejercicio 2. Variables en Kotlin. El programa mostrará como se declaran variables.

variables.kt

fun main(){
        println("\t ====== Kotlin =====")
        val nombre:String = "Thomas Muller"
        var cierto:Boolean = 34 > 88
        val car: Char = '\u0021'
        val flotante: Float = 32.1f
        val numero: Short = 2
        val entero: Int = 321
        val largo: Long = 1202020L
        val real: Double = 30303.88
        println("\t [Variables en Kotlin]")
        println("Hola, "+nombre)
        println("Es cierto?: "+cierto)
        println("Caracter: "+car)
        println("Numero: "+numero)
        println("Entero: "+entero)
        println("Largo: "+largo)
        println("Flotante: "+flotante)
        println("Real: "+real)
}

Y en Scala tenemos:

variables.scala

object Variables{
    
def main(args: Array[String]): Unit = {
   
        val nombre:String = "Thomas Muller"
        var cierto:Boolean = 34 > 88
        val car: Char = '\u0021'
        val flotante: Float = 32.1f
        val numero: Short = 2
        val entero: Int = 321
        val largo: Long = 1202020L
        val real: Double = 30303.88
        println("\t [Variables en Scala]")
        printf("Hola, %s\n",nombre)
        printf("Es cierto?: %b\n",cierto)
        printf("Caracter: %c\n",car)
        printf("Numero: %d\n",numero)
        printf("Entero: %d\n",entero)
        printf("Largo: %1d\n",largo)
        printf("Flotante: %.2f\n",flotante)
        printf("Real: %.2f\n",real)
    }

}

¿Qué se puede observar y por qué ambos lenguajes son tan parecidos?

1. Ambos usan la palabra reservada val para crear constantes. 
2. Ambos usan la palabra reservada var para crear variables. 
3. Los tipos de datos son prácticamente iguales (Int, Byte, Short, Doble , Float, Char, ...). 
4. Ambos permiten la programación funcional y la orientada a objetos.

Ejercicio 3. Crear un programa donde una clase Empleado herede de una clase Persona.

herencia.kt

fun main(){
  println("Herencia")
  val p1 : Persona= Persona()
  val emp1: Empleado = Empleado()

  if(p1 == emp1 ){
      println("Son objetos identicos")
  }

  if(p1 != emp1){
      println("No son objeto identicos")
  }

}


open class Persona{}
class Empleado(): Persona(){}

Se trata de un ejemplo básico de herencia en POO.

Ejercicio 4. Crear un programa que calcule el IMC de una persona. Los datos de entrada serán el peso y la talla(estatura). Se debe crear una función para obtener el IMC. Además de otra función para dar el veredicto de acuerdo al IMC obtenido.

imc.kt

import javax.swing.ImageIcon
import javax.swing.JOptionPane

// Método main
fun main(args: Array<String>): Unit{
   println(" [ IMC en Kotlin ] ")
   obtenerIMC()
}

// Calcula el índice de Masa Corporal
fun getIMC(peso:Double, talla:Double): Double{
  return peso/(talla*talla)
}

// Obtiene el veredicto del IMC
fun getVeredicto(imc:Double, peso:Double, talla:Double):String{
  var veredicto:String = "Peso: "+peso+"\nTalla: "+talla
  veredicto+="\nEl IMC obtenido es: "+imc+"\nVeredicto: "
  if(imc<16.00){
    veredicto+="Infrapeso: Delgadez Severa";
  }else if(imc<=16.00 || imc<=16.99){
    veredicto+="Infrapeso: Delgadez moderada";
  }else if(imc<=17.00 ||imc<=18.49){
    veredicto+="Infrapeso: Delgadez aceptable";
  }else if(imc<=18.50 || imc<=24.99){
    veredicto+="Peso Normal";
  }else if(imc<=25.00 || imc<=29.99){
    veredicto+="Sobrepeso";
  }else if(imc<=30.00 || imc<=34.99){
    veredicto+="Obeso: Tipo I";
  }else if(imc<=35.00 || imc==40.00){
    veredicto+="Obeso: Tipo III";
  }else{
    veredicto+="no existe clasificacion";
  }
  return veredicto
}

// Aquí se pedirán los datos de peso y talla
// y se obtendrá el resultado
fun  obtenerIMC(): Unit{
  var strPeso = JOptionPane.showInputDialog("Introduce peso: ")
  var strTalla = JOptionPane.showInputDialog("Introduce talla: ")
  var peso = strPeso.toDouble()
  var talla = strTalla.toDouble()
  val resultado: Double = getIMC(peso, talla)
  val veredicto = getVeredicto(resultado, peso, talla)
  JOptionPane.showMessageDialog(null, veredicto,"Resultado",JOptionPane.PLAIN_MESSAGE,ImageIcon("/home/user/Imagenes/imagen.png"));
}

Ejercicio 5. Crear un programa que resuleva un sistema de ecuaciones lineales; donde cada ecuación es de primer grado, definidas sobre un cuerpo. El programa tendrá tres funciones:

1. Una función para obtener el denominador.
2. Una función para realizar los cálculos.
3. Una función para mostrar el resultado.
   

ecuaciones.kt

// Método main
fun main(args: Array<String>): Unit{
   ecuaciones()
}

// Función para obtener denominador
fun denominador(a:Int, b:Int, c:Int, d:Int, e:Int, f:Int):Int{
  return (a*e)- (b*d)
}

// Función para realizar los cálculos
fun calcular(a:Int, b:Int, c:Int, d:Int, e:Int, f:Int, den:Int){
  var x = 0;
  var y = 0;

  x = ((c*e)-(b*f))/den
  y = ((a*f)-(c*d))/den
  println("Solucion: ")
  println("x = {x}\n y = {y}")
}

// Función donde se mostrará el resultado
fun ecuaciones(){
  println("[ Sistema de ecuaciones lineales en Kotlin]")
  val a = 2;
  val b:Int = 5;
  val c:Int = 12;
  val d:Int = 47;
  val e:Int = 30;
  val f = 71
  val den = denominador(a,b,c,d,e,f)
  if( den == 0){
    println("Sin solución: ${den}")
    calcular(a,b,c,d,e,f,den)
  }else{
    println("Denominador: ${den}")
  }

}

En próximas entregas continuaremos con este tema.

Enlaces:

https://codemonkeyjunior.blogspot.com/2019/01/conociendo-kotlin.html
https://www.coursera.org/learn/kotlin-for-java-developers/
https://kotlinlang.org/