Funções

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
}

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!")
}

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
}

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"
}

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)
}

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 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 linha

fun subtrair(){}

fun subtrair(a: Int){}

fun subtrair(a: Int, b: Int){}

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){

}

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
}

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)
}

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

}

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 'kotlinpara '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
}

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
}

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
}

fun retornoDois(t: Boolean) = if(t){
"Bom dia"
}else{
"Boa Noite"
}

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")
}
}