Operadores

Operadores

Observação: Os arquivos utilizados neste conteúdo que falam sobre os diversos tipos de operadores, são os seguintes:

Neste conteúdo você vai aprender sobre os operadores de atribuição, aritméticos, relacionais, lógicos e o famoso operador Elvis.

Operador de Atribução

No universo do Kotlin, nós podemos atribuir certos valores às nossas variáveis.

Se você acompanhou os conteúdos anteriores, você já deve ter notado que já usamos o operador de atribuição, que é o famoso sinal de igual (=).

Como o próprio nome já nos diz, o operador de atribuição, atribuí um valor/dado a algum outro lugar, que nesse caso é a uma variável.

Vejamos alguns exemplos abaixo:

var nome = "Micilini"//Estamos atribuindo o valor "Micilini" a variável chamada "Nome"
var idade = 30//Estamos atribuindo o valor 30 a variável chamada "idade"
var verdade = true//Estamos atribuindo o valor true a variável chamada "verdade"

Existem algumas variações dos operadores de atribuição, mas para que você possa entendê-los, é necessário que você conheça um pouco mais sobre os operadores aritméticos.

Operadores Aritméticos

Todo computador que se preze, é capaz de realizar operações aritméticas, tais como: adição, diminuição, multiplicação e divisão, e no Kotlin isso não é diferente.

No caso desse tipo de operador, eles são considerados operadores do tipo binário, e isso quer dizer que ele trabalha em cima de 2 operandos.

Vejamos como cada um deles funciona na prática.

 var idade = 30//Considerando que temos uma variável que armazena a idade de uma pessoa

//Exemplos de operadores aritméticos

idade = idade + 1//Operação da Soma (+)

idade = idade - 5;//Operação de Subtração (-)

idade = idade * 3//Operação de Multiplicação (*)

idade = idade / 2//Operação de Divisão (/)

idade = idade % 2//Operação de Resto da Divisão (%)

Também podemos usar estes mesmos operadores de forma um pouco mais resumida, isto é, em conjunto com o operador de atribuição, vejamos:

//Exemplos resumidos de se realizar operações Aritméticas:

idade += 5//Soma resumida

idade -= 2//Subtração Resumida

idade *= 3//Multiplicacao Resumida

idade /= 3//Divisão Resumida

idade %= 2//Resto da Divisão Resumido

Também podemos utilizar dois operadores de adição que representam uma incrementação, e dois operadores de diminuição que representam uma decrementação:

idade++//Incrementa + 1 a variável idade
idade--//Decrementação - 1 a variável idade

++idade//O compilador primeiro incrementa o valor de idade e depois ele o usa
--idade//O compilador primeiro incrementa o valor de idade e depois ele o usa

Existe alguma diferença real, se colocarmos o ++/-- na frente ou atrás da variável? Sim, vejamos:

var numero = 1
println(numero++)//Primeiro ele mostra 1 e depois incrementa ficando com 2, mas só mostra 1 no console

print(++numero)//Aqui ele já mostra o valor incrementado, pois o ++ veio primeiro

Outras formas de se representar operadores no Kotlin:

var a = 20
var b = 4

println("a + b = " + (a.plus(b)))
println("a - b = " + (a.minus(b)))
println("a * b = " + (a.times(b)))
println("a / b = " + (a.div(b)))
println("a % b = " + (a.rem(b)))

Operadores Relacionais

Quando nos referimos a operadores relacionais, estamos nos referindo a operações que fazemos para verificar a relação entre dois ou mais valores.

Existem 8 tipos de operações relacionais em Kotlin, são eles:

Vejamos cada um deles na prática:

//Operadores Relacionais:

val um = 5 > 10//Maior que
val dois = 10 < 98//Menor que
val tres = 50 >= 30//Maior ou igual a
val quatro = 44 <= 10//Menor ou igual a
val cinco = 44 === 44//Totalmente igual a (igual e do mesmo tipo)
val seis = 44 != 6//Diferente de
val sete = 1 == 1//Igual a
val oito = 1 !== 5//Não Igual e não do mesmo valor

//Cada um dos operadores retornam TRUE ou FALSE.

É importante ressaltar que o resultado dos operadores retornam true ou false.

Existem outras formas de se escrever estes operadores, vejamos:

//Existem outras formas de se escrever esses operadores:
val a = 10
val b = 20

println("c > d = " + (a.compareTo(b) > 0))
println("c < d = " + (a.compareTo(b) < 0))
println("c >= d = " + (a.compareTo(b) >= 0))
println("c <= d = " + (a.compareTo(b) <= 0))
println("c == d = " + (a?.equals(b) ?: (b === null)))

Podemos também inverter a condição de um operador, usando a negação (!):

//Invertendo a condição

println(!true)//Retorna False
println(!false)//Retorna True
println(!(1 < 5))//1 é menor que 5 e retorna true, mas a negação torna true para false

Operadores Lógicos

No mundo do Kotlin, os operadores lógicos são de extrema importância e se encontram frequentemente entre as linhas de códigos de diversos projetos.

Mas antes de entrarmos nesse assunto, precisamos entender um conceito bastante conhecido na computação chamado de tabela verdade.

Dentro dessa tabela nós temos a operação lógica do tipo &&, que diz assim: "Eu vou sair de casa, se o tempo estiver ensolarado e também eu tiver dinheiro no bolso".

Nesse tipo de operação, eu só sairia de casa se ambas as situações fossem verdadeiras, ou seja, eu só saio de casa se o tempo estiver ensolarado e eu tiver dinheiro no bolso.

Isso significa dizer que se uma das situações for falsa, eu não irei sair de casa. Ou seja, o dia está ensolarado, mas eu não tenho dinheiro no bolso... vou sair de casa? Não!

O dia está nublado e estou com bastante dinheiro no bolso... vou sair de casa? Também não!

Temos também o operador lógico do tipo ||, que diz assim: "Eu vou sair de casa, se o tempo estiver ensolarado ou se eu tiver dinheiro no bolso.".

Isso significa dizer que uma das situações precisam ser verdadeiras para que eu consiga sair de casa. Nesse caso eu só não sairia de casa se ambas fossem falsas, ou seja, se o dia não estivesse ensolarado e eu não tivesse nenhum dinheiro no bolso.

Nesse caso... se o dia estiver ensolarado e eu tiver dinheiro no bolso, eu vou sair? Sim!

Se o dia estiver ensolarado e eu não tiver nenhum dinheiro no bolso, eu ainda vou sair? Sim.

Se o dia estiver nublado e eu tiver bastante dinheiro no bolso, eu ainda vou sair? Sim.

Mas e se o dia estiver nublado e eu estiver zerado? Mesmo assim ainda vou sair? Não!

Por fim, e não menos importante, nos temos o famoso operador lógico de negação (!).

No caso dele, sua função é transformar uma afirmação verdadeira em falsa, e vice-versa.

Para nos aprofundarmos mais a fundo no conceitos dos operadores lógicos, vamos brincar um pouco com os valores booleanos quando se trata do AND (&&):

//Operador Lógico &&

val a= true && true //True, pois verdadeiro com verdadeiro é verdadeiro

val b= true && false //False, pois verdadeiro com falso é igual a falso

val c = false && true //False, não importa a ordem, eles ainda serão falsos

val d = false && false //False, pois o retorno final é falso

Vejamos agora como funciona o operador lógico OR (||):

//Operador Lógico ||

val e = true || true //True, pois uma delas precisa ser verdadeiro para retornar verdadeiro

val f = true || false //True, pois uma delas precisa ser verdadeiro para retornar verdadeiro

val g = false || true //True, pois uma delas precisa ser verdadeiro para retornar verdadeiro

val h = false || false //False, pois nenhuma delas é verdadeiro

É importante ressaltar que existe uma ordem de prioridade, em que a máquina executa cada um desses operadores:

Sobre o operador de negação, já vimos ele funcionando na seção de operadores relacionais, mas podemos brincar com ele um pouco nesta seção também:

val i = !true//Passa a ser false

val j = !false//Passa a ser true

É importante ressaltar que o Kotlin possui um operador que é capaz de calcular o intervalo de valores (range):

var n = 33

val resultado = (n >= 1 && n <= 50)
println(resultado)

val alternativa = (n in 1..50)
println(alternativa)

Operador Elvis

Chamado assim pois se parecem com o cantor Elvis de lado (?:) este tipo de operador nós permite imprimir uma variável baseado em alguma condição personalizada que você criar.

var str: String? = null

println(str ?: "nulo")//Pode ser uma variável ou função que retorne nulo, se for nulo, ele mostra a mensagem "nulo"

Conclusão

Neste conteúdo você aprendeu sobre os 5 tipos de operadores que podemos usar na linguagem Kotlin.

Até o próximo conteúdo 😀