Kotlin.

txt 1/6

Main.kt

package com.codemonkey

import spark.Spark.*;
import java.util.concurrent.atomic.*
import spark.kotlin.*
import com.google.gson.Gson;
import com.google.gson.JsonParseException;

object Main {
@JvmStatic
fun main(args:Array<String>){
demoA();
demoB()
demoC();
demoD()
demoE()
demoF()
demoG();
demoH();
demoI();
demoJ();
}

fun demoJ():Unit{
val gson:Gson = Gson();
val modelo:Modelo=Modelo("Europa Continental")
//De class a json
var classToJson = gson.toJson(modelo)

path("/api"){
//http://localhost:4567/api/modelos
get("/modelos"){req, res ->
res.type("application/json")
classToJson;
}//fin get
}//fin path

fun demoI(): Unit{

//usando spark.kotlin.*
val http: Http = ignite()
//http://localhost:4567/holaKotlin
http.get("/holaKotlin") {
"Hola Spark Kotlin!"
}

fun demoH(): Unit{

val alice = User(name = "Alice", email = "alice@alice.kt", id = 0)
val aliceNewEmail = alice.copy(email = "alice@bob.kt")
val (name, email) = aliceNewEmail
Kotlin.txt 2/6

println("$name's new email is $email")

val users = hashMapOf(

0 to User(name = "Alice", email = "alice@alice.kt", id = 0),
1 to User(name = "Bob", email = "bob@bob.kt", id = 1),
2 to User(name = "Carol", email = "carol@carol.kt", id = 2),
3 to User(name = "Dave", email = "dave@dave.kt", id = 3))

for((k,v) in users){
println(" ${k} -> ${v}")
}

fun demoG(): Unit{

get("/hola") { req, res -> "Spark Framework desde Kotlin" }
}

fun cadena(nada:Any): Unit{

if(nada !is String){
println("${nada} no es un String")
}else{
println("${nada} es un String")
}
}

// 'is' es el instanceof de Kotlin

fun demoF(): Unit{
val insecto: Insecto = Insecto()
if(insecto is Insecto){
println("insecto es un Insecto");
}

if(insecto is Animal){
println("insecto es un Animal")
}

cadena("4533")//4533 3s un String
cadena(121)//121 no es un String

val mapaAny: HashMap<Int,Any> = hashMapOf<Int,Any>(1 to Animal(), 2 to String(), 3 to

Insecto(), 4 to true)
for((k,v) in mapaAny){
demo(v)
}

fun demo(entrada:Any): Unit{

when(entrada){
is Animal -> println("${entrada} es Animal")
is String -> println("${entrada} es String")
is Insecto -> println("${entrada} es Insecto")
is Boolean -> println("${entrada} es Boolean")
}
}

enum class Moneda(val valor: String){

AGUILA("AGUILA IMPERIAL"),SOL("SOL NACIENTE");
Kotlin.txt 3/6

fun demoE(): Unit{

var moneda: Moneda = Moneda.SOL;
var valor: String = Moneda.SOL.valor;
println("Moneda: ${moneda}")
println("Valor: ${valor}");
println("***************")
val valores = Moneda.values()
valores.forEach { println("Nombre: "+it.name) }
Moneda.values().forEach(::println)
}

fun demoD(): Unit {

var mapaModelos:Map<String,Modelo> = hashMapOf<String,Modelo>("1" to Modelo("Madrid"),
"2" to Modelo("El Cairo"))
println(mapaModelos.toString())
print("Tam: ${mapaModelos.size}\n")
println("Elemento con clave 1: "+mapaModelos.get("1"))
for((key,value) in mapaModelos){
println("$key : $value")
}
println()
mapaModelos.forEach { (key, value) -> println("$key = $value") }
}

fun demoC():Unit{
val mapa = hashMapOf("Alpha" to 1, "Omega" to 2)
println(mapa["Alpha"])//1
val snapshot: Map<String, Int> = HashMap(mapa)
println(snapshot)
println(mapa)
println("Tam:${mapa.size}")
mapa.put("Beta",3)
mapa.put("Gamma",4);

//Recorrer mapa con for

for ((key, value) in mapa) {
println("$key = $value")
}
//recorrer mapa con for each
mapa.forEach { (key, value) -> println("$key = $value") }
println(mapa.get("Beta"))//3

mapa.remove("Beta");
println(mapa)
println("Tam:${mapa.size}")
mapa.clear()
println(mapa)
println("Tam:${mapa.size}")

fun demoB():Unit{
var arrayInt: Array<Int> = arrayOf<Int>(1,2,3,4,5,6);//size=6
println("Tam array: ${arrayInt.size}");
val listaChar: List<Char> = listOf<Char>('V','\ufff0','$','#');//size=4
println("Tam list: ${listaChar.size}");
arrayInt[2] = 33
Kotlin.txt 4/6

println(arrayInt[2])//33
println(listaChar.toString())
println()
for(array:Int in arrayInt){
println("${array}")
}
println()
for(item:Char in listaChar){
println("${item}")
}

var mutableListChar: MutableList<Char> = mutableListOf<Char>('A')

mutableListChar.add(1,'B')// ['A','B']
mutableListChar.add(2,'A')// ['A','B','A']
mutableListChar.set(0,'C')//['C','B','A']
println(mutableListChar.toString())//['C','B','A']

fun demoA():Unit{
//val computadora: Computadora = Computadora()
val computadoraEscritorio: ComputadoraEscritorio = ComputadoraEscritorio()
print("\n")
val computadoraPortatil: ComputadoraPortatil = ComputadoraPortatil()
print("\n")
computadoraEscritorio.encender();
print("\n")
computadoraPortatil.encender();

when(computadoraPortatil.isBateriaLlena()){
true -> println("Bateria de la computadora esta llena")
else -> println("Es necesario poner a recargar la bateria")
}

}
}

data class User(val name: String, val email: String, val id: Int);

class UserDao {

val users = hashMapOf(

0 to User(name = "Alice", email = "alice@alice.kt", id = 0),
1 to User(name = "Bob", email = "bob@bob.kt", id = 1),
2 to User(name = "Carol", email = "carol@carol.kt", id = 2),
3 to User(name = "Dave", email = "dave@dave.kt", id = 3)
)

var lastId: AtomicInteger = AtomicInteger(users.size - 1)

fun save(name: String, email: String) {

val id = lastId.incrementAndGet()
users.put(id, User(name = name, email = email, id = id))
}

fun findById(id: Int): User? {

return users[id]
Kotlin.txt 5/6

fun findByEmail(email: String): User? {

return users.values.find { it.email == email }
}

fun update(id: Int, name: String, email: String) {

users.put(id, User(name = name, email = email, id = id))
}
fun delete(id: Int) {
users.remove(id)
}

open class Animal

class Insecto:Animal()

data class Modelo(var nombre:String)

open class Computadora{
init{
println("Objeto Computadora creado e inicializado")
}

//Los metodos encender() y apagar()

// son final, se coloca open
// para que sus clases hijas
// puedan sobreescribirlos
open fun encender(): Unit{
println("Encender computadora")
}

open fun apagar(): Unit{

print("\nApagar computadora")
}
}
class ComputadoraEscritorio:Computadora(){
init{
println("Objeto ComputadoraEscritorio creado e inicializado")
}

override fun encender(): Unit{

println("Encender computadora de escritorio")
}

override fun apagar(): Unit{

print("\nApagar computadora de escritorio")
}
}
class ComputadoraPortatil:Computadora(){
var capacidad:Int = 10
init{
println("Objeto ComputadoraPortatil creado e inicializado")
}

override fun encender(): Unit{

println("Encender computadora portatil")
}
Kotlin.txt 6/6

override fun apagar(): Unit{

print("\nApagar computadora portatil")
}

//Por default es final

fun isBateriaLlena(): Boolean{
return this.capacidad >=100;
}
}

build.gradle
buildscript {
ext.kotlin_version = '1.3.10'

repositories {
mavenCentral()
}
dependencies {
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
}
}

apply plugin: 'kotlin'

apply plugin: 'application'

mainClassName = "com.codemonkey.Main"

repositories {
mavenCentral()
}

dependencies {
compile group: 'com.google.code.gson', name: 'gson', version: '2.8.5'
compile "com.sparkjava:spark-kotlin:1.0.0-alpha"
compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
}

compileKotlin {
kotlinOptions.jvmTarget = "1.8"
}
compileTestKotlin {
kotlinOptions.jvmTarget = "1.8"
}