0

Kotlin: Criação de uma classe e seus comportamentos

#Kotlin
Wellington Santos
Wellington Santos

Olá, ${coloque_uma_saudação_legal_aqui}, 

Este é meu segundo artigo de uma série onde e tento explicar os conceitos básicos na criação de classes. Essas são coisas que aprendi no curso e quero compartilhar aqui meu entendimento, talvez ajude alguém, ao mesmo tempo que me ajuda a fixar o conhecimento que adquiri, além de poder receber feedbacks caso esteja errado ou esteja faltando algo no meu entendimento.


O primeiro artigo está aqui, caso tenha curiosidade:

https://web.digitalinnovation.one/articles/kotlin-criacao-de-uma-classe-e-suas-propriedades


Métodos

Os métodos (por vezes referidos como "operações" ou serviços) são procedimentos que formam os comportamentos e ações oferecidos por objetos de uma classe, sendo responsáveis por alterar o estado ou fornecer informações sobre um objeto. (Wikipedia)


Este é um tópico um pouco extenso, mas vou tentar me focar no básico sobre ele, ou este artigo pode facilmente ficar gigantesco.

Em Kotlin um método é declarado usando a palavra chave fun seguido pelo nome do método e parêntesis opcionalmente contendo parâmetros dentro deles.

Caso seu método retorne algum valor, ele deve declarar isso logo depois dos parêntesis, funciona exatamente como declarar o tipo de uma variável, você deve usar ":" seguidos pelo tipo de valor que será retornado, se não for retornar nada, você pode definir o tipo de retorno como Unit, mas isso pode ser omitido.

Também opcionalmente você pode definir um modificador de acesso ao método, que funciona da mesma forma que nas propriedades, como explicado no artigo anterior, caso for omitido o método será public. E tudo isso junto forma o que chamamos de assinatura do método.


fun soma(termo1: Int, termo2:Int): Int {
  return termo1 + termo2
}


Para usar um método você geralmente precisa apenas usar um ponto e o nome da função seguida por parêntesis, e dentro desses parêntesis os argumentos caso sua função especifique algum (numa chamada de método os parâmetros passam a se chamar argumentos).


class Cofrinho {
  private var dinheiros: Double = 0.0

  public fun depositar(quantidade: Double):Unit { // Usar retorno Unit é opcional
    dinheiros += quantidade 
  }
	
  public fun contarDinheiros():Double {  // retorna um número decimal
	return dinheiros      // dinheiros é um Double então está tudo bem retornar ele.
  }
}

fun main(){
  val porquinho = Cofrinho()
  /* Chamada sem argumento e retorna um número decimal */
  println(porquinho.contarDinheiros()) 

  /* vamos colocar 5 dinheiros com esse método sem retorno */
  porquinho.depositar(5.0) 

  /* agora tem dinheiro pra contar */
  println(porquinho.contarDinheiros())

  /** (╥_╥) E como eu pego meu dinheiro de volta? */
}


Caso você tenha mais de um parâmetro no seu método, os argumentos devem ser passados na ordem declarada na assinatura, mas também é possível definir para qual parâmetro esse valor está sendo atribuído caso use o nome na chamada, para o caso de você esquecer a ordem dos argumentos devem ser passados.


Você também pode fornecer valores padrão para os parâmetros do seu método, assim eles se tornam opcionais para o código cliente.


Vou modificar o método depositar para receber 2 argumentos o primeiro continua sendo o valor, e se não for passado nenhum valor, assumirá o valor 1, o segundo é o nome de quem está depositando, seu valor padrão será uma String vazia, e serve apenas para ilustrar como usar métodos com mais de uma argumento.


class Cofrinho {
  private var dinheiros: Double = 0.0

  public fun depositar(quantidade: Double = 1.0, depositante: String = ""):Unit {
    if(depositante.isNotBlank()){
      /* É um cofrinho educado, imprime uma mensagem */
      println("Obrigado $depositante S2!") 
    }
  dinheiros += quantidade
  }
	
  public fun contarDinheiros():Double {
    return dinheiros
  }
}

fun main(){
  val porquinho = Cofrinho()
  /* Depositará quietamente 1.0 dinheiro */
  porquinho.depositar()  

  /* Depositará 10 dinheiros e agradecerá */		
  porquinho.depositar(10.0, "João")   

  /* Especifica que Pedro é o depositante */ 	
  porquinho.depositar(depositante = "Pedro") 

  /* Está fora da ordem, mas está usando parâmetros nomeados */
  porquinho.depositar(depositante = "Maria", quantidade = 1.0)

  /* Erro! o primeiro parâmetro espera um Double não um João */
  porquinho.depositar("João") 		
} 


Você ainda pode usar a notação infix para deixar seus métodos mais extravagantes e poderem ser chamadas sem um ponto. Para isso ela deve preencher os 3 requisitos:


  • A função deve ser declarada dentro da classe, não funciona com funções externas


  • Deve possuir apenas um parâmetro.


  • Não pode possuir valor padrão


Vamos modificar novamente o método depositar...


class Cofrinho {
  private var dinheiros: Double = 0.0

  infix public fun depositar(quantidade: Double):Unit {
    dinheiros += quantidade
  }
	
  public fun contarDinheiros():Double {
    return dinheiros
  }
}

fun main(){
  val porquinho = Cofrinho()

  /* Depositará extravagantemente 7 dinheiros */
  porquinho depositar 7.0  			

  /* Será que depositou mesmo? (☉̃ₒ☉) */
  println( porquinho.contarDinheiros() )	
} 


Ok, vou parar por aqui, está ficando longo. Para mais informações deem uma olhada na documentação

https://kotlinlang.org/docs/functions.html


Na próxima eu falo sobre construtores ou sobre os métodos que você nem sabia que estava declarando quando cria uma propriedade.


Dúvidas, sugestões e comentários em geral são sempre bem vindos.

0
3

Comentários (2)

0
Wellington Santos

Wellington Santos

02/07/2021 13:28

Eu descobri isso ontem na aula do Jether Rodrigues, Aplicando Conceitos de Coleções, Arrays e Listas, ele citou infix na aula e eu fui pesquisar o que era, e já adicionei aqui. 😆


0
Lázaro Bonfim

Lázaro Bonfim

02/07/2021 13:21

Muita boa, não sabia que tinha esse negócio de Infix, na minha visão deixa o código um pouco estranho kkk

Tentando aprender um pouco mais a cada dia

Brasil