Cuando no reconoce los elementos el MainActivity

 If you are using Android Studio 4.1, you need to add the description to build.gradle (Module:.app).

Si está utilizando Android Studio 4.1, debe agregar la descripción a build.gradle (Módulo: .app).

plugins {
    id'com.android.application'
    id'kotlin-android'
    id'kotlin-android-extensions'
}

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

Destructuración - Destructuring declarations

 //Lección 8 Kotlin Intermedio: Destructuring declarations

private fun destructuringDeclarations(){
    val rene = Worker("Rene", 36, "Programador")
    //La destructuración permite crear varias variables de una sola vez
    val (nombre, edad, trabajo) = rene
    //Si no quiero acceder a edad se hace un subrayado
    val (nombre2, _, trabajo2) = rene
    println("Mi nombre es $nombre, mi edad $edad y mi profesión $trabajo")
    println("Tambien puedo imrpimir asi ${rene.component1()}")
    //Destructurando una función
    val (name, age, work) = myWorker()
    println("Los datos traidos desde la funcion son $name, $age y $work")
    //Destructuración en las colecciones, en mapas en concreto
    //Un mapa nos permitía crear clave-valor
    val myMap = mapOf(1 to "Brenda", 2 to "Ian", 3 to "XXX")
    //Recorriendo el mapa
    for (element in myMap){
        println("${element.key} , ${element.value}")
        //Asi se usa la descomposición
        println("${element.component1()} , ${element.component2()}")
    }
    //Otra forma de destructuralizar
    for ((llave, nombre) in myMap){
        println("Llave-> $llave - Nombre-> $nombre")

    }
}

private fun myWorker(): Worker {
    return Worker("Rene", 33, "Programador abap")
}

Types aliases

 //Leccion 7 Kotlin Intermedio: Type aliases

package com.mouredev.kotlinintermedio

import android.graphics.Path
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import java.util.ArrayList

//typealias, sirve para tipos de datos, para funciones y en clases anidadas
typealias MyMapList = MutableMap<Int, ArrayList<String>> //Esto sirve para simplificar las definiciones
typealias  MyFun = (Int, String, MyMapList) -> Boolean

typealias  MyNestedClass = MyNestedAndInnerClass.MyNestedClass

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

//private var myMap: MutableMap<Int, ArrayList<String>> = mutableMapOf()
private var myMap: MyMapList = mutableMapOf()
private fun typeAliase(){
    //var myNewMap : MutableMap<Int, ArrayList<String>> = mutableMapOf()
    var myNewMap : MyMapList = mutableMapOf()

    myNewMap[1] = arrayListOf("Rene","Zayas")
    myNewMap[2] = arrayListOf("Zarenet", "por Rene Zayas")

    myMap = myNewMap
}

Data classes

 //Lección 6 Kotlin Intermedio; Data classes

private fun dataClasses(){
    val rene = Worker("Rene",36,"Programador")
    rene.lastWork = "Predicador"

    //Funciones que nos permite el data class
    //equals & hashCode, para compara objetos
    if (rene.equals("SARA")){
        println("Son iguales")
    } else {
        println("No son iguales")
    }
    //toString
    println(rene.toString()) //Imprime todos los datos
    //Copy
    val rene2 = rene.copy(age = 30) //La opcion de copiar te permite modificar algunos datos
    println(rene2.toString()) //Imprime todos los datos

    //component - Funcion que se encarga de descomponer en estructuras mas sencillas
    val (name, age) = rene
    println(name)
    println(age)
}

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

data class Worker(val name:String = "", val age:Int = 0, val work:String = ""){
    var lastWork:String = "" //Esto no será obligatorio

}

Modificadores de visibilidad - Visibility Modifiers

 //Lección 5 Kotlin Intermedio: Visibility Modifiers

private fun visibilityModifiers(){
    val visibility = VisibilityTwo()
    visibility.name = "Rene"
    visibility.sayMyName()
}

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

private class Visibility { //Modificador de visibilidad public, por defecto es public
    //Public nos permite visibilidad en cualquier parte de nuestra aplicación
    //Private solo permite dentro del archivo donde se encuentra la declaración
    //Protected Es casi igual que privado, excepto que el acceso no estará disponible para declaraciones de nivel superior y si para nivel inferior
    //Internal, declaraciones visibles y accesibles desde cualquier parte del modulo (nuestra APP)
    var name :String? = null

    private fun sayMyName(){
        name?.let { //let ->Desempaquetando el valor de name en caso que no sea nula
            //En caso que name tenga valor lo imprimiremos
            println("My name es $it")
        } ?: kotlin.run {
            println("No tengo nombre")
        }
    }
}

open class VisibilityTwo{
    protected fun sayMyNameTwo(){
        val visibility = Visibility()
        visibility.name= "Rolando"
    }
}

class VisibilituThree: VisibilityTwo(){
    internal val age:Int? = null
    fun sayMyNameThree(){
        sayMyNameTwo()
    }
}

Interface

 private fun interfaces(){

    //val gamer : Game //No podemos instanciarla ->() porque no posee estado y no puede utilizarse por si sola
    val gamer = Person("Rene",36)
    gamer.play()
    gamer.stream()
}

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

interface Game { //Una interface no puede poseer estado -> () <-No puede poseer un constructor
                //En clase abstracta si se puede agregar una propiedad en su constructor -> (myGame:String)

    val game: String    //Se puede definir propiedades
    fun play() //No hae falta que se diga que es abstracta ya que es una interface

    fun stream(){ //Con esto stream tiene un corportamiento por defecto pero puede ser reemplazado
        println("Estoy haciendo stream de mi juego $game") //Le doy un comportamiento a la interface
    }
}

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

open class Person(name:String, age:Int) : Work(), Game { //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")
    }

    //override val game: String
    //    get() = "FIFA"
    override val game: String = "Fifa" //Otra forma de dar valor a game

    override fun play() {
        println("Esta persona está jugando $game")
    }
}