Kotlin: Introdução ao Kotlin e Filosofia de Design

// Java: 20+ linhas apenas para definir um simples POJO
public class Order {
    private String id;
    private BigDecimal total;
    private String status;

    public Order(String id, BigDecimal total, String status) {
        this.id = id;
        this.total = total;
        this.status = status;
    }

    public String getId() { return id; }
    public BigDecimal getTotal() { return total; }
    public String getStatus() { return status; }

    @Override
    public boolean equals(Object o) { /* 10+ linhas */ }
    @Override
    public int hashCode() { /* 5+ linhas */ }
    @Override
    public String toString() { /* 3+ linhas */ }
}

// Kotlin: 1 linha faz tudo
data class Order(val id: String, val total: BigDecimal, val status: String)

// commonMain - compartilhado entre todas as plataformas
expect fun logMessage(message: String)

// Plataforma JVM
actual fun logMessage(message: String) = println("[JVM] $message")

// Plataforma JS
actual fun logMessage(message: String) = console.log("[JS] $message")

// Tipo não nulo: NÃO pode ser null
val orderId: String = "ORD-001"

// Tipo anulável: DEVE usar o sufixo ?
val customerName: String? = null

// Operador de chamada segura
val length = customerName?.length  // null se customerName for null

// Operador Elvis: fornece um padrão
val name = customerName ?: "Desconhecido"

// Asserção não nula: lança NPE se for null (use com cautela)
val forced = customerName!!

// ============================================
// OrderProcessor - Primeiro Programa Kotlin
// Funcionalidade: Definir modelo de pedido e imprimir resumo
// ============================================

// Data class: auto-gera equals/hashCode/toString/copy
data class Order(val id: String, val total: Double, val status: String)

data class Customer(val name: String, val email: String?)

fun main() {
    // Criar pedidos
    val order1 = Order("ORD-001", 299.99, "SHIPPED")
    val order2 = Order("ORD-002", 1_500.00, "PROCESSING")

    // Cliente anulável
    val customer: Customer? = Customer("Alice", "alice@example.com")

    // Chamada segura + operador Elvis
    val email = customer?.email ?: "no-email"

    // Template de string
    println("Pedido: ${order1.id}, Total: \$${order1.total} USD, Status: ${order1.status}")
    println("Email do cliente: $email")

    // Expressão when (como switch, mas mais poderosa)
    val priority = when {
        order2.total > 1_000 -> "HIGH"
        order2.total > 500 -> "MEDIUM"
        else -> "LOW"
    }
    println("Pedido ${order2.id} prioridade: $priority")

    // Smart cast
    val result: Any = order1
    if (result is Order) {
        // Nenhuma conversão explícita necessária!
        println("Smart cast: ${result.id} - ${result.total} USD")
    }
}

Pedido: ORD-001, Total: $299.99 USD, Status: SHIPPED
Email do cliente: alice@example.com
Pedido ORD-002 prioridade: HIGH
Smart cast: ORD-001 - 299.99 USD

fun main() {
    println("Hello, Kotlin!")
}

Hello, Kotlin!

val name = "Alice"
var age = 30
fun greet(n: String): String = "Hello, $n!"
println(greet(name))

Hello, Alice!

data class User(val name: String, val age: Int)
val alice = User("Alice", 30)
println(alice)

User(name=Alice, age=30)

// Operadores - sem promoção numérica implícita; precisa de .toInt() explícito
val intVal: Int = 42
val longVal: Long = 42L
val doubleVal: Double = 3.14

// Aritmética
val sum = intVal + 100
val product = intVal * 2

// Comparação - retorna Boolean
val isPositive = intVal > 0
val isEqual = intVal == 42L  // false! Int != Long

// Conversões explícitas
val widened = intVal.toLong()
val narrowed = doubleVal.toInt()  // 3 (truncado)

println("sum=$sum, product=$product, isPositive=$isPositive")
println("widened=$widened, narrowed=$narrowed")

sum=142, product=84, isPositive=true
widened=42, narrowed=3

val orders = listOf(
    "ORD-001" to 299.99,
    "ORD-002" to 1500.00,
    "ORD-003" to 50.00,
    "ORD-004" to 3200.00
)

// forEach - ação em cada elemento
orders.forEach { (id, total) ->
    println("$id: \$$total USD")
}

// map - transformação
val totals = orders.map { it.second }
println("Totais: $totals")

// filter - filtragem
val highValue = orders.filter { it.second > 500.0 }
println("Pedidos de alto valor: ${highValue.size}")

// sum - soma os valores
val grandTotal = totals.sum()
println("Total geral: \$${grandTotal} USD")

ORD-001: $299.99 USD
ORD-002: $1500.0 USD
ORD-003: $50.0 USD
ORD-004: $3200.0 USD
Totais: [299.99, 1500.0, 50.0, 3200.0]
Pedidos de alto valor: 2
Total geral: $5049.99 USD

fun describeOrder(order: Any): String = when (order) {
    is String -> "ID do pedido: $order"
    is Int -> "Número inteiro: $order"
    is List<*> -> "Lista com ${order.size} elementos"
    in 1..10 -> "Número no intervalo 1-10: $order"
    "special" -> "Valor especial"
    else -> "Tipo desconhecido"
}

println(describeOrder("ORD-001"))
println(describeOrder(42))
println(describeOrder(listOf(1, 2, 3)))
println(describeOrder(7))
println(describeOrder("special"))
println(describeOrder(3.14))

ID do pedido: ORD-001
Número inteiro: 42
Lista com 3 elementos
Número no intervalo 1-10: 7
Valor especial
Tipo desconhecido