DevSupportDocs/kotlin.md

## Documentación Kotlin

### Comentarios

```kotlin
// Comentario en una línea

/*
   Comentario multilinea
*/

/**
* Comentario para documentación
*/
```

### Variables mutables

Se debe usar siempre la inferencia de tipos, aunque se pueda asignar el tipo de variable. La inicialización aquí es, de facto, obligatoria.

```kotlin
var nombreVariable[: tipo] = valor

var nombreVariable: Byte|Short|Int|Long = 1[L]
var nombreVariable: Float|Double 1.1[F]
var nombreVariable: Boolean = true
var nombreVariable: Char = 'a'
var nombreVariable: String = "qwerty"
```

### Variables inmutables

```kotlin
val nombreVariableInmutable[: tipo] = valor
```

### Constantes

Las constantes se deben declarar e inicializar en ámbito global.

```kotlin
const val nombreConstante[: tipo] = valor
```

### Operadores

Aritméticos

   | Operación      | Signo | Uso     | Resultado |
   | -------------- | ----- | ------- | --------- |
   | Suma           | +     | a=5,b=5 | a+b=10    |
   | Resta          | -     | a=5,b=5 | a-b=0     |
   | Multiplicación | *     | a=5,b=5 | a*b=25    |
   | División       | /     | a=5,b=3 | a/b=1     |
   | Módulo         | %     | a=5,b=3 | a%b=2     |

Unarios

   | Operación       | Signo | Uso    | Resultado |
   | --------------- | ----- | ------ | --------- |
   | Cambio de signo | -     | a=-1   | -a=1      |
   | Convierte a int | +     | a=F    | +a=70     |
   | Decremento      | --    | a=5    | --a=4     |
   | Incremento      | ++    | a=5    | ++a=6     |
   | Negación lógica | !     | a=true | !a=false  |

De asignación

   | Operación         | Signo | Uso  | Resultado |
   | ----------------- | ----- | ---  | --------- |
   | Suma/asigna       | +=    | a=5  | a+=3; 8   |
   | Multiplica/asigna | *=    | a=5  | a*=3; 25  |
   | Resta/asigna      | -=    | a=5  | a-=3; 2   |
   | Divide/asigna     | /=    | a=5  | a/=3; 1   |
   | Módulo/asigna     | %=    | a=5  | a%=3; 2   |
   | Asigna            | =     | a=5  |  a=3; 3   |

Relacionales

   | Operación         | Signo | Uso      | Resultado   |
   | ----------------- | ----- | -------  | ----------- |
   | Igual a           | ==    | a=5,b=3  | a==b; false |
   | Distinto que      | !=    | a=5,b=3  | a!=b; true  |
   | Menor que         | <     | a=5,b=3  |  a<b; false |
   | Mayor que         | >     | a=5,b=3  |  a>b; true  |
   | Menor o igual que | <=    | a=5,b=3  | a<=b; false |
   | Mayor o igual que | >=    | a=5,b=3  | a>=b; true  |

Lógicos

   | Resultado                      | Signo | Uso       |
   | ------------------------------ | ----- | --------- |
   | si a es false, b no se evalúa  | &&    | a&&b      |
   | si a es false, b no se evalúa  | \|\|  | a\|\|b    |

Operaciones con bits

   | Resultado                      | Signo  | Uso      |
   | ------------------------------ | ------ | -------- |
   | Operación AND                  | and()  | a and b  |
   | Operación OR                   | or()   | a or b   |
   | Operación XOR                  | xor()  | a xor b  |
   | Operación NOT                  | inv()  | a.inv()  |
   | Mueve en a bits de b a izq     | shl()  | a shl b  |
   | Mueve en a bits de b a dcha    | shr()  | a shr b  |
   | Igual, pero sin el signo (-)   | ushr() | a ushr b |

### Tratamiento de null

Primero es necesario especificar que el elemento permite valores null, para ello se añade ? en la declaración

```kotlin
   var nombreVar: tipo? = valor
```

Una vez desbloqueada la limitación, se debe controlar la posibilidad de que tome un valor null con:

  1. Condicionales
      > val test = if (nombreVar != null) nombreVar else -1
  2. Llamadas seguras (?.)
      > println(nombreVar?.toInt())
  3. Operador Elvis (?:)
      > println(nombreVar ?: -1)
  4. Operador !!
      > println(nombreVar!!)
  5. Método let
      > nombreVar?.let { println($it) }

### Funciones

Función simple

```kotlin
// Declaración
fun nombreFuncion(){
   foo.bar
}

// Llamada
nombreFuncion()
```

Función con parámetros

```kotlin
// Declaración
fun nombreFuncion(param1: tipo, param2: tipo){
   foo.bar(param1 + param2)
}

// Llamada
nombreFuncion(arg1, arg2)
```

Función con retorno

```kotlin
// Declaración
fun nombreFuncion(param1: tipo, param2: tipo): tipoRetorno{
   return param1 + param2
}

// Llamada
tipo nombreVariable = nombreFuncion(arg1, arg2)
```

### Clases

Declaración

```kotlin
class Clase [{...}]
```

Constructor (forma parte de la cabecera)

```kotlin
class Clase(val propiedad1: Tipo, val propiedad2: Tipo) [{...}]
```

Sobrecarga de constructores

```kotlin
```




```kotlin
```