Extensiones - extensions

 //Lección 9 Kotlin Intermedio: Extensions

private fun extensions(){
    val myDate = Date()
    println(myDate.customFormat())
    println("La longitud del texto fue de -> ${myDate.formatSize} caracteres") //seaccede a ella en forma de propiedad no de funcion

    var myDateNudable: Date? = null
    println(myDateNudable.customFormat())
}

-----------------------------------

package com.mouredev.kotlinintermedio

import java.text.SimpleDateFormat
import java.util.*
//Primero la clase que vamos a extender Date
//Despues del punto podemos poner el nombre que queremos(customFormat). Estas funciones se añadir a Date
//Esta operacion va a devolver un string
fun Date?.customFormat(): String{
    val formatter = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZZZ", Locale.getDefault())
    return formatter.format(this) //This hace referencia a la clase base
}

//Extension de propiedad
//La clase que queremos extender es Date. La operacion se llama formatSize
//Esta constante va a calcular el string generado por customFormat
val Date.formatSize : Int
    get()  = this.customFormat().length //El método de acceso a la constante

Clases herencia - Class Inheritance

 //Lección 3 Kotlin Intermedio: Class Inherentance

private fun classInheritance(){
    val programmer = Programmer("Rene",36, "Kotlin")
    programmer.work()
    programmer.sayLanguage()
    programmer.goToWork()
}

-----------

open class Person(name:String, age:Int) : Work() { //Propiedades nombre y edad //Open permite que la clase sea heredada
    //Cualquier clase tiene una superclase común "Any"

    open fun work(){
        println("Esta persona está trabajando")
    }

    override fun goToWork() {
        //TODO("Not yet implemented")
        println("Esta persona va al trabajo")
    }
}
------------------
class Programmer(name:String, age:Int, var language: String):Person(name, age) { //language paso de propiedad a variable

    override fun work() { //Aqui se puede sobreescribir una funcion - Para especializarla
        //super.work() //Hace referencia a la funcion original
        println("Esta persona está programando")
    }

    fun sayLanguage(){
        println("Este programador usa el lenguaje $language")
    }
}
----------------------
abstract class Work { //Esto es una clase abstracta, sirve para definir solamente un comportamiento
    abstract fun goToWork()
}

Nested and Inner Classes

 //Lección 2 Kotlin Intermedio: Nested and Inner Classes

private fun nestedAndInnerClasses(){

    //Clase anidada (nested)
    val myNestedClass = MyNestedAndInnerClass.MyNestedClass()
    val sum:Int = myNestedClass.sum(3, 5)
    println("El resultado de la suma es $sum")

    //Clase interna (inner)
    val myInnerClass = MyNestedAndInnerClass().MyInnerClass()
    val sumOne = myInnerClass.sumOne(10)
    println("El resultado de sumOne es $sumOne")
}

------------------

class MyNestedAndInnerClass {

    private val one = 1


    //Clase interna (Inner Class)
    inner class MyInnerClass{ //Con la clase interna se puede acceder a valores que estan afuera (one)
        fun sumOne(number:Int): Int{
            return number + one
        }
    }


}

Enum classes

 enum class Direction(val dir: Int){ //Lo que está en () son propiedades y se puede agregar más

    NORTH(1), SOUTH(-1), EAST(1), WEST(-1); //Hay que poner ; para agregar más cosas

    fun description(): String{
        return when(this){  //Si no esta todos los valores nos dará error
            NORTH   -> "La direccion es NORTE"
            SOUTH   -> "La direccion es SUR"
            //EAST    -> "La direccion es ESTE"
            //WEST    -> "La direccion es OESTE"
            else    -> "No sabemos la direccion"
        }
    }
}
//Lección 1: Kotlin intermedio: Enum Classes
private fun enumClasses() {
    var userDirection: Direction? = null
    println("Direccion: $userDirection")
    userDirection = Direction.SOUTH
    println("Direccion: $userDirection")
    //Propiedad por defecto
    println("Propiedad name: ${userDirection.name}")
    println("Propiedad name: ${userDirection.ordinal}")
    //Funciones
    println(userDirection.description())
    //Inicializacion
    println(userDirection.dir)
}

Clases

 //Clases

fun clases(){
    val rubend = Programmer("Rubend", 36, arrayOf(Programmer.Language.ABAP))
    val gustavom = Programmer("Gustavo", 4, arrayOf(Programmer.Language.JAVA), null)
    val rene = Programmer("Rene", 36, arrayOf(Programmer.Language.KOTRIN, 

Programmer.Language.ABAP), arrayOf(rubend, gustavom))
    println("El nombre del programador es ${rene.name}")
    println("La edad del programador es ${rene.age}")
    rene.codigos()
}

-----------------------

class Programmer(val name:String, val age:Int, val langueges: Array<Language>, var friends: Array<Programmer>?=null) {

    //Solo estos valores se permiten en el lenguages
    enum class Language {
        KOTRIN,
        JAVA,
        ABAP,
        C
    }

    fun codigos(){
        for(languege: Language in langueges) {
            println("El lenguaje que maneja el programador es $languege")
        }
    }
}