Tipos Genéricos e Const

Tipos Genéricos e Const

Observação: Os arquivos utilizados neste conteúdo que falam sobre os tipos genéricos e const são:

Pronto para iniciar seu aprendizado?

O que são tipos genéricos?

E se eu te dissesse que é possível criar uma função que receba qualquer tipo de valor?

Sim, e isso é possível usando os tipos genéricos, observe a seguinte função abaixo:

fun <T, J> minhaFuncaoDois(idade: T, outro: J){
//Exemplo de função genérica com dois tipos
}

Ali estamos usando as letras T e J, mas poderíamos usar qualquer tipo de letra.

É importante ressaltar que por padrão a comunidade costuma reversar as letras G, T e J para fazer referências a tipos genéricos.

Beleza, se nós podemos enviar qualquer tipo de valor para a minhaFuncaoDois, por exemplo:

minhaFuncaoDois(idade: 34, outro: true)

minhaFuncaoDois(idade: "Roll", outro: 77)

Como é que validamos isso dentro da função?

Simples, para isso você pode fazer validações, checando o tipo de dado que cada parâmetro da função armazena:

fun <T, J> minhaFuncaoDois(idade: T, outro: J){
if(outro is String){//Verifica se o tipo genérico é do tipo String
println("A variável Outro é do tipo String")
}

if(outro is Int){
println("A variável Outro é do tipo Int")
}

if(outro is Boolean){
println("A variável Outro é do tipo Boolean")
}
}

Tipo Const

Em outras linguagens de programação, nós podemos ter a variável do tipo const, que representa uma constante, que é um valor que não se altera, não muda.

Só que no Kotlin, nós já temos a variável do tipo val, que é considerada uma constante, ao mesmo tempo que não conseguimos alterar o seu valor.

Nesse caso, o que faz o const no Kotlin?

Bem, diferente de outras linguagens, aqui elas são consideradas TOP LEVEL DECLARATION.

Podendo ser declaradas fora de qualquer escopo, como estamos vendo no exemplo abaixo, em que ela é declarada acima do escopo do MAIN:

const val a = 10//O const precisa sempre ser inicializado! Não é possível atrelar funções ou classes para dentro do const

fun main(){
//Função Main...
}

Além disso const não pode ser usado dentro de funções, nem dentro de classes, e nem dentro de variáveis. Pois ele precisa ficar em um escopo maior.

Apesar de não termos chegado ainda no conteúdo que fala sobre classes, vou deixar abaixo algumas dicas do uso do CONST abaixo:

Por fim, nós podemos acessar o CONST como se fosse uma variável qualquer, e podemos fazer isso dentro da função MAIN, ou dentro de qualquer função ali existente:

const val a = 10

fun main() {
println("Valor da Constante [a]: ${a}")
}

O uso do ANY

No Kotlin, nós temos o tipo de dado conhecido como ANY, que significa "qualquer".

Ele é um tipo de dado que dá origem a todos os outros tipos, tais como Int, Boolean, String e afins.

Quando definimos uma variável na qual seu tipo é ANY:

//Exemplo de variáveis do tipo Any

var minhaVariavel: Any = 12
var minhaVariavelDois: Any = "Meu Texto"

Ainda assim, conseguimos alterar o valor da variável desde que ela seja do tipo Any e Var:

minhaVariavel = "Olá Mundo"

Exemplo de funções que aceitam o tipo Any:

fun main(){
valores(12)
valores("olá mundo")
valores(true)
}

fun valores(value: Any){//Aqui ele consegue receber qualquer tipo de dado
print(value)
}

Lembrando que podemos ter uma função de retorno que retorne o tipo Any, ou seja, o retorno pode ser qualquer tipo de dado:

fun valores(value: Any): Any{//Aqui ele consegue receber qualquer tipo de dado
return value
}

O uso do Unit

Como aprendemos em conteúdos anteriores, nós vimos que algumas funções não tem retorno algum, e essas opcionalmente podem ser declaradas também com o tipo Unit.

Em outras linguagens, Unit tem o mesmo peso que o Void, que são funções que não possuem um retorno.

fun minhaFuncao(valor: Int): Unit{//Significa que a função não tem retorno

}

O uso do Nothing

Nothing significa nada, e é um tipo de dado especial que é muito usado para retornar uma função que ainda não foi implementada.

Usamos o Nothing quando queremos retornar uma exceção da função.

Geralmente dentro dessas funções, usamos o comando TODO que significa a fazer, e serve para indicar funções ou comandos que ainda não foram implementados no sistema.

Este comando é usado para fazer o lançamento de exceções, exceções que ainda não foram implementadas no nosso sistema.

fun minhaFuncaoDois(valor: String): Nothing{
TODO("Não Implementado!")
//return 23//Não podemos retornar nada com o Nothing
}

Lembrando que não podemos retornar qualquer tipo de valor quando usando Nothing, somente um comando TODO, ok?

De resto não é comum ver uma função com nothing, pois não conseguimos retornar nada que não seja uma exceção.

Qual é uso real do Nothing?

Vamos imaginar que o desenvolvedor A, está fazendo o back-end do sistema, e o desenvolvedor B esta fazendo outra parte do back-end que está mais relacionada com o banco de dados.

Supondo que o desenvolvedor A terminou mais rápido que o desenvolvedor B, e que agora o desenvolvedor A precisa da função "de "SALVAR" no banco de dados.

Ele pede para que o desenvolvedor B desenvolva tal função.

Só que, o desenvolvedor B ainda não fez essa função... nesse caso o desenvolvedor A criaria somente a estrutura da função de salvar, e diz que seu retorno será NOTHING.

Onde dentro dessa função existirá um TODO, que irá lançar uma exceção alegando "Não implementado" ou "Não terminado" ou "Não tive tempo".

fun salvarNoBandoDeDados(valores: Any): Nothing{
TODO("Aguardando implementação do desenvolvedor B...")
}

Com isso o desenvolvedor A consegue seguir com o desenvolvimento do sistema, pois ele já sabe dos métodos que precisam ser chamados.

Conclusão

Neste conteúdo, aprendemos um pouco mais sobre os diversos tipos genéricos, e a variável do tipo TOP LEVEL DECLARATION chamada CONST.

Até o próximo conteúdo 🥳