🔗 Tarefa
Reescreva o código fornecido usando smart casts e a expressão when do Kotlin.
Java
class Java { public int eval(Expr expr) { if (expr instanceof Num) { return ((Num) expr).getValue(); } if (expr instanceof Sum) { Sum sum = (Sum) expr; return eval(sum.getLeft()) + eval(sum.getRight()); } throw new IllegalArgumentException("Unknown expression"); } } C#
public interface Expr { } public class Num : Expr { public int Value { get; set; } } public class Sum : Expr { public Expr Left { get; set; } public Expr Right { get; set; } } public int Eval(Expr expr) { if (expr is Num num) return num.Value; if (expr is Sum sum) return Eval(sum.Left) + Eval(sum.Right); throw new ArgumentException("Unknown expression"); } Dart
abstract class Expr {} class Num implements Expr { final int value; Num(this.value); } class Sum implements Expr { final Expr left, right; Sum(this.left, this.right); } int eval(Expr expr) { if (expr is Num) return expr.value; if (expr is Sum) return eval(expr.left) + eval(expr.right); throw ArgumentError('Unknown expression'); } Go
package main type Expr interface{} type Num struct { Value int } type Sum struct { Left, Right Expr } func Eval(expr Expr) int { switch e := expr.(type) { case Num: return e.Value case Sum: return Eval(e.Left) + Eval(e.Right) default: panic("Unknown expression") } } JavaScript
function eval(expr) { if (expr instanceof Num) { return expr.value; } if (expr instanceof Sum) { return eval(expr.left) + eval(expr.right); } throw new Error("Unknown expression"); } class Num { constructor(value) { this.value = value; } } class Sum { constructor(left, right) { this.left = left; this.right = right; } } TypeScript
interface Expr { } class Num implements Expr { constructor(public value: number) { } } class Sum implements Expr { constructor(public left: Expr, public right: Expr) { } } function eval(expr: Expr): number { if (expr instanceof Num) return expr.value; if (expr instanceof Sum) return eval(expr.left) + eval(expr.right); throw new Error("Unknown expression"); } PHP
interface Expr {} class Num implements Expr { public $value; function __construct($value) { $this->value = $value; } } class Sum implements Expr { public $left, $right; function __construct($left, $right) { $this->left = $left; $this->right = $right; } } function evalExpr($expr) { if ($expr instanceof Num) return $expr->value; if ($expr instanceof Sum) return evalExpr($expr->left) + evalExpr($expr->right); throw new Exception("Unknown expression"); } Python
class Expr: pass class Num(Expr): def __init__(self, value): self.value = value class Sum(Expr): def __init__(self, left, right): self.left = left self.right = right def eval_expr(expr): if isinstance(expr, Num): return expr.value if isinstance(expr, Sum): return eval_expr(expr.left) + eval_expr(expr.right) raise ValueError("Unknown expression") Swift
protocol Expr {} class Num: Expr { let value: Int init(_ value: Int) { self.value = value } } class Sum: Expr { let left, right: Expr init(_ left: Expr, _ right: Expr) { self.left = left; self.right = right } } func eval(_ expr: Expr) -> Int { if let num = expr as? Num { return num.value } if let sum = expr as? Sum { return eval(sum.left) + eval(sum.right) } fatalError("Unknown expression") } Casos de uso
Em programação, cada tipo de dado é representado e operado diferentemente na memória. O "casting" é uma técnica usada para informar ao compilador que uma variável deve ser tratada como outro tipo. Isso permite realizar operações específicas com essa variável, além de garantir a compatibilidade com outras partes do código.
Em Kotlin, existe um recurso do compilador chamado Smart casts que rastreia verificações de tipos (como com o operador is) e infere automaticamente o seu tipo quando necessário.
Verificação de tipo e inferência
Verificação positiva
Ao verificar uma variável com o operador is, e se a verificação for bem-sucedida, Kotlin reconhece imediatamente o tipo dessa variável dentro do bloco de código:
class Gato(val emojiGato: String = "🐱") class Cachorro(val emojiCachoro: String = "🐶") class Peixe(val emojiPeixe: String = "🐟") class Pássaro(val emojiPassaro: String = "🐦") fun falar(animal: Any): String { return when (animal) { is Gato -> "Miau ${animal.emojiGato}" is Cachorro -> "Au au ${animal.emojiCachoro}" is Peixe -> "Blub blub ${animal.emojiPeixe}" is Pássaro -> "Pi pi ${animal.emojiPassaro}" else -> "Não reconhecemos esse animal." } } fun ondeVive(animal: Any) { if (animal is Gato || animal is Cachorro) { println("Vive em terra.") } else if (animal is Peixe) { println("Vive na água.") } else if (animal is Pássaro) { println("Vive no ar e na terra.") } else { println("Não reconhecemos esse animal.") } } Verificação negativa
Usando ! antes do operador is, é possível reagir quando a variável não é do tipo esperado:
class Ave(val canto: String) class Macaco(val grito: String) class Reptil(val som: String = "Ssssss") fun documentarSom(animal: Any) { if (animal !is Ave) return print("O som da ave é: ${animal.canto}") } // Testando a função val tucano = Ave("Pi-pi-piu") documentarSom(tucano) // Saída: "O som da ave é: Pi-pi-piu" Limitações com variáveis mutáveis (var)
O compilador pode não realizar um Smart Cast se não puder garantir que o valor da variável não mudou entre o momento da verificação e o momento do uso:
open class Animal class Cachorro() : Animal() { fun alimentar() = Unit } var animal: Animal? = Cachorro() if (animal is Cachorro) { animal = null animal.alimentar() // Erro de compilação: Smart cast para 'Cachorro' é impossível } Smart Casts com operadores lógicos
Kotlin vai além e integra a capacidade de "Smart Casts" com operadores lógicos como && e ||. Isso evita a necessidade de conversões explícitas, tornando o código mais limpo e legível.
open class Animal(val nome: String, val energia: Int = 100) class Peixe(nome: String, energia: Int, val habitatPreferido: String) : Animal(nome, energia) { fun explorar() = "está explorando o habitat $habitatPreferido!" } class Passaro(nome: String, energia: Int, val tipoBico: String) : Animal(nome, energia) { fun bicar() = "está usando seu bico $tipoBico para buscar comida!" } fun acaoEspecifica(animal: Animal) { when { animal is Peixe && animal.energia > 50 -> { println("${animal.nome} ${animal.explorar()}") } animal is Passaro && animal.tipoBico == "afiado" -> { println("${animal.nome} ${animal.bicar()}") } else -> { println("${animal.nome} não está realizando uma ação específica no momento.") } } } // Testando a função val tilapia = Peixe("Tilápia", 60, "lago de água doce") val aguia = Passaro("Águia", 80, "afiado") val canario = Passaro("Canário", 50, "pequeno") acaoEspecifica(tilapia) // Saída: "Tilápia está explorando o habitat lago de água doce!" acaoEspecifica(aguia) // Saída: "Águia está usando seu bico afiado para buscar comida!" acaoEspecifica(canario) // Saída: "Canário não está realizando uma ação específica no momento." Vantagens
- Sintaxe limpa e código legível: permite um código mais limpo, direto e legível, evitando repetições de conversões explícitas de tipo.
- Segurança de tipo: o compilador realiza o Smart Cast apenas quando é seguro, reduzindo a possibilidade de erros de conversão em tempo de execução.
- Integração com controle de fluxo: dentro de controles condicionais como
if,else,when, ou loops comofor,while, o Kotlin reconhece e ajusta o tipo da variável de acordo, permitindo o acesso direto a suas propriedades específicas sem necessidade de casting explícito.
Desvantagens
- Limitações com Variáveis Mutáveis: com variáveis mutáveis, Smart Casts pode não ser garantido pelo compilador, já que o tipo pode ter mudado entre a verificação e o uso.
- Concorrência: em ambientes com múltiplos threads, o Smart Cast pode apresentar riscos se uma variável for alterada por outro thread após a verificação.
- Potencial confusão com lógica complexa: em certas lógicas condicionais, o compilador pode não conseguir inferir o tipo, mesmo que pareça claro para o desenvolvedor.
Analogia
Ao ouvir o canto de um pássaro específico na floresta, um ornitólogo pode identificar imediatamente a espécie, mesmo sem vê-la. Esse reconhecimento imediato permite ao especialista saber tudo sobre esse pássaro, desde seus hábitos até seu habitat.
O Smart Cast no Kotlin age de forma semelhante, permitindo utilizar o tipo específico assim que identificado, sem necessidade de verificações adicionais.
Top comments (0)