Funções
Observação: Os arquivos utilizados neste conteúdo que falam sobre funções em geral, são respectivamente:
Neste conteúdo vamos aprender sobre funções, funções matemáticas e os usos das funções de strings que são disponibilizadas pela linguagem.
O que são Funções?
De modo geral, o Kotlin conta com uma estrutura de blocos popularmente conhecida como funções.
Elas são consideradas "subprogramas" de um programa principal, por vezes chamadas de código externo/interno de uma aplicação em Kotlin.
As funções seguem um esquema bem parecido com as estrutura de controle de fluxo (If/Else) e também com as estruturas de iterações (for, while...), isso porque ela também trabalha com blocos de código usando chaves.
Veja como funciona uma função no Kotlin:
fun main() {
olaMundo()//Modo de chamar a função, pode ser chamado quantas vezes quiser
}
fun olaMundo(){//Função simples que não recebe parâmetros nem retorno
println("Olá Mundo!")//Dentro da função podemos ter diversos comandos
}Podemos dizer ao Kotlin que aquela função não possui retorna de forma um pouco mais explícita, e nos podemos fazer isso usando o Unit:
fun main() {
olaMundoUnit()//Mesma lógica do de cima
}
fun olaMundoUnit(): Unit{//Significa que essa função não tem retorno, deixa isso de forma explícita (opcional usar Unit quando não tem retorno)
println("Olá Mundo!")
}As funções, elas podem ter algum tipo de retorno. Veja no exemplo abaixo uma função que retorna um dado do tipo STRING:
fun main() {
val retorno = olaMundoRetorno()//Como essa função retorna algo, estamos salvando numa variável, mas poderiamos imprimir direto no println
}
fun olaMundoRetorno(): String{//Função que retorna uma string
return "Olá Mundo"//usamos o return para retornar
}Também é suportado chamar uma função enviando parâmetros a ela:
fun main() {
println(mensagem("Micilini"))//Chamando uma função com 1 parâmetro
}
fun mensagem(nome: String): String{//Função com parâmetro e retorno de string
return "Olá $nome"
}Veja agora um outro exemplo, onde estamos enviando dois parâmetros:
fun main(){
println(soma(10, 2))//Chamando uma função com dois parâmetros
}
fun soma(a: Int, b: Int): Int{//Função com mais de um parâmetro que faz a soma
return (a + b)
}Veja agora o uso da interpolação de uma função sendo chamada dentro de um println():
fun main(){
println("A soma de 10 e 2 é: ${soma(10, 2)}")//Uso da interpolação
}
fun soma(a: Int, b: Int): Int{//Função com mais de um parâmetro que faz a soma
return (a + b)
}
Funções com um único retorno
É possível criar funções que contenham apenas um único retorno, vejamos o exemplo:
fun somaDois(a: Int, b: Int): Int = (a + b)//Tipo de função que tem apenas um único comando
fun somaTres(a: Int, b: Int) = (a + b)//Tipo de função que tem apenas um único comando, dessa vez sem o INT (pois o JVM se vira para identificar o retorno)
fun helloWorld() = println("Hello, world!")//Função que não tem retorno, mas é única linhaVariações de uma mesma função
No kotlin, podemos ter diversas funções com o mesmo nome, desde que cada uma delas trate seus parâmetros de forma diferente:
fun subtrair(){}
fun subtrair(a: Int){}
fun subtrair(a: Int, b: Int){}Funções com parâmetros adicionais
Nem sempre queremos criar uma função em que todos os parâmetros são obrigatórios, sendo assim, podemos definir alguns deles como opcionais:
fun main(){
endereco(estado = "Rio de Janeiro", rua = "Brazilis", cidade = "Rio de Janeiro")//Aqui estamos passando os parâmetros de forma desordenada.
//É importante ressaltar que a função acima só trocar a ordem da declaração dos parâmetros, mas não influencia em nada na função.
//Se em um parâmetro você teve que informar o nome, você precisa informar todos até o fim!
}
fun minhaFuncao(rua: String, cep: Int = 99999999){
//Você chamaria essa função assim: minhaFuncao("Rua Bellas Artes"), e poderiamos usar o cep com o valor padrão.
//Caso desejar, você poderia passar o cep também: minhaFuncao("Rua Bellas Artes", 21521478)
}
fun endereco(rua: String, cidade: String, estado: String){
}Uso do Vararg
No Kotlin nós temos um tipo de variável chamada vararg que permite receber diversos tipos de parâmetros em uma função:
fun main(){
media(1f, 2f, 3f, 4f, 5.98f);//Exemplo de multiplos parâmetros com vararg
}
//Recebendo múltiplos parâmetros dentro de uma única variável:
fun media(vararg notas: Float){
var soma = 0f
var tamanho = notas.size//Size é o tamanho das variáveis que vieram
for(n in notas){
soma +=n
}
println(soma/tamanho)//Resultado da média
}
Println, Print e Main também são funções
Analisando o que aprendemos até aqui, podemos perceber que os comandos Println(), Print() e até mesmo o Main são considerados funções.
Pois a forma como estamos chamando eles, e até mesmo os declarando (como é o caso do Main) acontece da mesma forma como fizemos com nossas funções.
fun main(){//A função principal main também não deixa de ser considerada uma função.
//Println e Print também são funções!
println("")//Função padrão do Kotlin que printa no console (com quebra de linha)
print("")//Mesma lógica anterior (sem quebra de linha)
}Funções Matemáticas
O kotlin nos disponibiliza algumas funções da própria linguagem que nos ajuda a realizar algumas operações matemáticas, vejamos algumas delas:
import kotlin.math.*//Como estamos usando mais de uma biblioteca de Math o Kotlin importa todas de uma vez
fun main() {
//Funções Matemáticas
println(max(5, 10))//Retorna o maior número entre dois valores
println(min(5, 10))//Retorna o menor número entre dois valores
println(sqrt(45.68))//Retorna a raíz quadrada do valor
println(PI)//Retorna o PI
println(E)//Retorna o Euler
println(round(12312.234234234))//Arredondar para cima
}Lembrando que precisamos importar a biblioteca de funções matemáticas para ter acesso a essas funções (import kotlin.math.*)
Para saber mais sobre as funções do tipo Math e conhecer outras acesse este link.
Funções de Formatação de Strings
Em conteúdos anteriores, vimos como formatar strings usando o console.
Agora vamos conhecer algumas funções um pouco mais avançadas que nos ajudam a formatar o tipo STRING:
fun main(){
//Exemplo de uso de funções que formatam STRINGS:
val meuTexto = "Programação Kotlin"
println("Tamanho da String: ${meuTexto.length}")//Retorna o tamanho da string
println("Posição 0 da string: ${meuTexto[0]}")//Retorna o elemento da posição 0 da string
println("Começa com Pro? ${meuTexto.startsWith("Pro", false)}")//Verifica se a string começa com algum texto. IgnoreCase ignora caso sensitivo (maiusculo minusculo)
println("Termina com abc? ${meuTexto.endsWith("abc")}")//Mesma lógica de cima, só que invertido (termina com)
println(meuTexto.substring(2))//Pula duas posições e começa a partir daí
println(meuTexto.substring(2, 4))//Retorna da posição 3 até 4
println(meuTexto.replace("Kotlin", "Android"))//Troca as string, de 'kotlin para 'Android'
println(meuTexto.lowercase())//Converte tudo para minúsculo
println(meuTexto.uppercase())//Converte para maiúsculo
println(meuTexto.trim())//Elimina espaços em branco no início e no final da string
}Com essas funções nós podemos converter um texto para maiúsculo, minúsculo, selecionar o primeiro caractere, eliminar espaços em branco, fazer substituições e entre outras coisas.
Usando Funções com Controle de Fluxo
Também é possível fazer o uso de funções com algumas estruturas que já conhecemos relacionadas ao controle de fluxo, vejamos alguns exemplos.
Usando o IF/ELSE:
fun main(){
//Podemos ter um retorno direto
val resultado = retornoUm(true)
}
fun retornoUm(t: Boolean): String{
return if(t){
"Bom dia"
}else{
"Boa Noite"
}//Esse return do IF só funciona se existir
}Outros exemplos de retorno:
fun main(){
println("Maior de Idade? ${maiorDeIdade(15)}")
}
fun maiorDeIdade(idade: Int): Boolean{
if(idade > 18){
return true
}
return false
//Poderiamos ter retornado assim: return (idade > 18), pois o proprio retorno é um booleano
}Exemplo de uma função de retorno direto:
fun retornoDois(t: Boolean) = if(t){
"Bom dia"
}else{
"Boa Noite"
}Usando o While:
fun main(){
//Exemplo de funções com o controle de fluxo While:
println(bonusWhen("Engenheiro de Software"))
println(whenComRange(5))
println(whenComBoolean(false))
}
//Funções com While:
fun bonusWhen(cargo: String): Float{
return when(cargo){
"Gerente" -> 2000f
"Coordenador" -> 1500f
"Engenheiro de Software" -> 1000f
"Estagiário" -> 500f
else -> 0f
}//Exemplo de When com Retorno automático
}
fun whenComRange(n: Int): Unit{
when(n){
in 1..10 -> println("1...10")
in 10..20 -> println("10...20")
}
}
fun whenComBoolean(b: Boolean): Unit{
when(b){
true -> println("Verdadeiro")
false -> println("Falso")
}
}Conclusão
Neste conteúdo aprendemos bastante coisa sobre o uso de funções.
Aprendemos a como criar, chamar, passar parâmetros obrigatórios e opcionais, funções matemáticas, funções de strings, e o uso do controle de fluxo atuando em conjunto com funções.
Até o próximo conteúdo 😃
