Ejercicios en Kotlin

README.md

Kotlin

Kotlin para prgramadores Java

Main.kt

package ejemplos

//Compilar:
// kotlinc Main.kt -include-runtime -d main.jar
//Ejecutar:
// java -jar main.jar

import javax.swing.ImageIcon
import javax.swing.JOptionPane
import java.lang.System
import java.util.Date


fun main(args: Array<String>): Unit{
   println(" [ Programando en Kotlin ] ")
   testA()  
   testB()
   testC()
   testD()
   testE()
   testF()
   testG()
   testH()
   testI()
}

fun denominador(a:Int, b:Int, c:Int, d:Int, e:Int, f:Int):Int{
  return (a*e)- (b*d)
}

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}")
}

fun positivo(num:Int):Int{
  if(num < 0){
    return num*(-1);
  }
  return num;
}


fun testI(){
  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}")
  }

}

fun testH(){
  println("\t [ Excepciones ]")
  val lista = listOf("A","B","C");
  
  try {
    val result = 25 / 0
  } catch (ex: NumberFormatException) {
    println("Ha ocurrido una NumberFormatException: "+ex.message);
  } catch (ex: ArithmeticException) {
    println("Ha ocurrido una ArithmeticException: "+ex.message);
  } catch (ex: Exception) {
    println("Ha ocurrido una excepcion: "+ex.message);
  }

  println("=========================================")

  try{
    println(lista[3])
  }catch(ex: StringIndexOutOfBoundsException){
    println("Ha ocurrido una StringIndexOutOfBoundsException: "+ex.message);
  }catch(ex: Exception){
    println("Ha ocurrido una excepcion: "+ex.message);
  }

  println("=========================================")

  val docXML: GeneradorXML = GeneradorXML("archivo.xml",0)
  try{
    docXML.verificando()
  }catch(ex: MyException){
    println("Ha ocurrido una MyException: "+ex.message);
  }finally{
    println("Hecho!!")
  }
  println("========================================")
  val puntoColor: PuntoColor = PuntoColor(4,6,"RED")
  try{
    puntoColor.generar()
  }catch(ex: MyException){
    println("Ha ocurrido una MyException: "+ex.message);
  }

  println("========================================")

  val documentoNuevo = DocumentoPDF("el origen de todo.".capitalize())
  try{
    documentoNuevo.imprimir()
  }catch(ex: MyException){
    println("Excepcion al imprimir documento ${ex.message}")
  }

  println("========================================")
  
}

fun getIMC(peso:Double, talla:Double): Double{
  return peso/(talla*talla)
}

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
}


fun testG() {
    val sam = RestaurantCustomer("Sam", "Mixed salad")
    sam.greet() // An implementation of an abstract function
    sam.order() // A member function
    sam.eat() // An implementation of an interface function
    sam.pay(10) // A default implementation in an interface

    val docXML: GeneradorXML = GeneradorXML("libro.xml",3)
    docXML.inicio()
    docXML.generar()
    docXML.exportar()

    val presupuesto: PresupuestoAnual = PresupuestoAnual(56000.00, Date(2022, 8, 22) ,"Este es el presupuesto anual")
    println("${presupuesto.datos()}")
}


fun testF(){
  println("\t [Indice de Masa Corporal en Kotlin]")
  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/fernando/Imágenes/ferd.png"));
  //System.exit(0)
}

fun testE():Unit{
   val fecha = java.util.Date()
   JOptionPane.showMessageDialog(null,"Hoy es $fecha")
   val nombre:String = JOptionPane.showInputDialog("Escribe tu nombre:")
   JOptionPane.showMessageDialog(null,"Hola $nombre")
   val resultado:String = "Nombre: Fernando\nEdad: 40 años\nPeso: 55 kg\nTalla: 1.55 m"
   JOptionPane.showMessageDialog(null, resultado,"Resultado",JOptionPane.PLAIN_MESSAGE,ImageIcon("/home/fernando/Imágenes/ferd.png"));
   val mapaJava = java.util.HashMap<String, String>()
   mapaJava.put("mensaje","Hola, mundo")
   println("Mapa Java: ${mapaJava.toString()}")
   println("Get mensaje: ${mapaJava.get("mensaje")}")
   mapaJava.clear()
   mapaJava.put("mensaje","Hola, mundo")
   mapaJava.put("message","Hello world")
   println("Mapa Java: ${mapaJava.toString()}")
   mapaJava.remove("mensaje")
   println("Mapa Java: ${mapaJava.toString()}")
   mapaJava.clear()
   //System.exit(0)
}

fun testD():Unit{
   val lista: List<String> = listOf("Alef", "Bet", "Gimmel","Dalet","Hei","Vav")
   println(lista.toString())
   println("\tFor:")
   for (i in lista.indices) {
      println("Letra: "+lista[i]) 
   }
   println("\tWhile:")
   val itr = lista.listIterator()
   while (itr.hasNext()) {
      println("Letra: "+itr.next())
   }
   println("\tFor in:")
   for (s in lista) {
      println("Letra: "+s)
   }
   println("\tFor each:")
   lista.forEach { println("Letra: "+it) }
}

fun testC(): Unit{
    var cadena:String = "BOB";
    println("\t [ PALINDROMA EN KOTLIN ]")
    println("Palabra: ${cadena}");
    cadena = quitaEspacios(cadena);
    if(esPalindroma(cadena)){
      println("Es palindroma");
    }else{
      println("No es palindroma");
    }
    println("============================")
    val palabras = listOf("BOB","ANA","SANA","TENET","JULIET","REMER")
    println("Lista: ${palabras}");
    for (i in palabras.indices) {
      //println("Nombre: "+palabras[i])   
      if(esPalindroma(quitaEspacios(palabras[i]))){
         println(palabras[i]+" >> Es palindroma");
      }else{
         println(palabras[i]+" >> No es palindroma");
      }

    }
  }

  fun esPalindroma(cadena:String):Boolean{
    var resultado:Boolean=false;
    var cadenaTmp:String="";
    var contador:Int = cadena.length;
    while(contador-->=0){
      try{
        var cr = cadena.get(contador);
        cadenaTmp += cr.toString();
      }catch(ex: StringIndexOutOfBoundsException){
        println("");
      }
    }

    if(cadenaTmp.equals(cadena)){
      resultado = true;
    }
    return resultado;
  }

  fun quitaEspacios(cadena:String):String{
    var cadenaTmp:String="";
    var contador:Int=cadena.length;
    while(contador-->= 0){
      try{
        var cx = cadena.get(contador);
        if(!" ".equals(cx.toString())){
          cadenaTmp += cx.toString();
        }
        //println("${cadenaTmp}")
      }catch(ex:StringIndexOutOfBoundsException){
          println("");
      }
    }
    return cadenaTmp;
  }

fun testB():Unit{
   var numero:Int = 90
   var flotante: Float = 1.23f
   var largo: Long = 100000L
   var real: Double = 345.980
   var my_byte: Byte = 2
   var my_short:Short = 2
   var car:Char = '\u0011'
   var titulo:String = "Este es un titulo de algun libro."
   var booleano:Boolean = false
   println("Int: ${numero}")
   println("Float: ${flotante}")
   println("Double: ${real}")
   println("Byte: ${my_byte}")
   println("Short: ${my_short}")
   println("Long: ${numero}")
   println("Char: ${car}")
   println("String: ${titulo}")
   println("Boolean: ${booleano}")
   println("Positivo: ${positivo(-342)}")
}


fun testA(): Unit{
   val x:X = X("Juan O'Donoju")
   println("Hola, ${x.nombre}")
   
   val a:A = A("J.J Jameson");

   if("J.J Jameson".equals(a.nombre)){
      println("Hola, ${a.nombre}");
   }

   if(a is A){
      println("Es de tipo A");
   }

   val es_a = a is A;
   println("${es_a}");
   val verdadero = es_a?:"Esto es verdadero"
   println("Salida: ${verdadero}");
   var nulo = null;
   val vacio = nulo?:"Esto se vera"
   println("Salida: ${vacio}"); 

   val my_p:P = P();
   val my_q:Q = Q();

   my_p.g();
   my_q.g();

}

class X(val nombre:String)
open class A(val nombre:String)
open class P {
    open fun g() {
      println("Funcion g en clase P");
    }
}

class Q : P() {
    public open override fun g() {
      println("Funcion g en clase Q");
    }
}


abstract class Person(val name: String) {
    abstract fun greet()
}

interface FoodConsumer {
    fun eat()
    fun pay(amount: Int) = println("Delicious! Here's $amount bucks!")
}

class RestaurantCustomer(name: String, val dish: String) : Person(name), FoodConsumer {
    fun order() = println("$dish, please!")
    override fun eat() = println("*Eats $dish*")
    override fun greet() = println("It's me, $name.")
}

interface IGenerador{
  fun generar()
}

abstract class Generador(val nombre: String){
  abstract fun exportar()
}
class GeneradorXML(nombre: String, val paginas: Int): Generador(nombre),IGenerador{
  fun inicio() = println("Iniciando...")
  override fun generar() = println("Generando documento XML...")
  override fun exportar() = println("Se exporto el archivo $nombre con $paginas paginas!") 

  fun verificando(){
    if(paginas == 0){
      throw MyException("Error: numero de paginas no debe ser >>"+paginas)
    }else{
      println("Verificando...")
    }  
  }
}

abstract class Presupuesto(val monto:Double, val fecha: Date){
  abstract fun datos():String
}

class PresupuestoAnual(monto:Double, fecha:Date, val descripcion:String):Presupuesto(monto,fecha){
  override fun datos():String{
    return "PresupuestoAnual{Monto: "+monto+", fecha: "+fecha+", descripcion: "+descripcion+"}"
  }
}


class MyException(message:String): Exception(message)

abstract class Punto(val x:Int,val y:Int){
  abstract fun generar()
}

class PuntoColor(x:Int, y:Int,val color:String):Punto(x,y){
  override fun generar(){
    if((x == 0 || x<0) || (y==0 || y<0)){
      throw MyException("Ningun valor de x o y deberia ser 0")
    }
    else{
      println("Generando PuntoColor{color="+color+", x="+x+", y="+y+"}")
    }
  }
}

abstract class Documento(val titulo:String){
  abstract fun imprimir()
}

class DocumentoPDF(titulo:String):Documento(titulo){
  override fun imprimir(){
    if(titulo !=null && !titulo.isEmpty()&& titulo.length > 0){
      println("Generando documento: ${this.titulo}")
    }else{
      throw MyException("No se pudo generar el documento: ${this.titulo}")
    }
  }
}