Partilha esta página

Aprende X em Y minutos

Onde X=kotlin

Kotlin é uma linguagem de programação de tipificação estática para a JVM, Android e browser. Ela é 100% interoperável com Java. Lê mais aqui.

// Comentários de linha começam com //
/*
Comentários de múltiplas linhas são assim.
*/

// A palavra-chave "package" funciona da mesma forma que em Java.
package com.learnxinyminutes.kotlin

/*
O ponto de entrada de um programa em Kotlin é a função chamada "main".
Esta função tem como único parâmetro um array contendo todos os argumentos passados na linha de comandos.
Desde a versão 1.3 que esta pode também ser definida sem parâmetros.
*/
fun main(args: Array<String>) {
    /*
    A declaração de variáveis é feita usando "var" ou "val".
    Variáveis declaradas com "val" não podem ser redefinidas, já as declaradas com "var" podem.
    */
    val fooVal = 10 // não podemos redefinir mais tarde o valor de fooVal para algo diferente
    var fooVar = 10
    fooVar = 20 // fooVar pode ser redefinida

    /*
    Na maioria dos casos, o Kotlin pode determinar (inferir) o tipo de uma variável,
    assim não precisamos de o dizer explicitamente sempre.
    Para especificar o tipo explicitamente fazemos assim:
    */
    val foo: Int = 7

    /*
    As Strings são representadas de uma forma semelhante ao Java.
    O escape é feito com barras invertidas.
    */
    val fooString = "A minha String está aqui!"
    val barString = "Imprimir numa nova linha?\nSem problemas!"
    val bazString = "Adicionar um tab?\tSem problemas!"
    println(fooString)
    println(barString)
    println(bazString)

    /*
    Uma raw string é delimitada por aspas triplas (""").
    Raw strings podem conter caracteres de nova linha ou qualquer outro.
    */
    val fooRawString = """
fun helloWorld(val name : String) {
    println("Hello, world!")
}
"""
    println(fooRawString)

    /*
    As strings podem também conter template expressions.
    Uma template expression começa com o símbolo do dollar ($).
    */
    val fooTemplateString = "$fooString tem ${fooString.length} caracteres"
    println(fooTemplateString) // => A minha String está aqui! tem 25 caracteres

    /*
    Para que uma variável possa ter o valor de null esta tem de ser 
    especificada explicitamente como nullable.
    Uma variável pode ser marcada como nullable adicionando um ? ao seu tipo.
    A variable can be specified as nullable by appending a ? to its type.
    Usando o operador ?. podemos facilmente aceder a propriedades de 
    uma variável nullable, se esta for null o resultado da expressão será também ele null.
    Podemos também usar o operador ?: para especificar um valor alternativo
    no caso da variavél ser null.
    */
    var fooNullable: String? = "abc"
    println(fooNullable?.length) // => 3
    println(fooNullable?.length ?: -1) // => 3
    fooNullable = null
    println(fooNullable?.length) // => null
    println(fooNullable?.length ?: -1) // => -1

    /*
    As funções são declaradas usando a palavra-chave "fun".
    Os parâmetros da função são especificados entre parênteses a seguir ao nome da função.
    Estes parâmetros podem opcionalmente ter um valor por omissão.
    O tipo de retorno da função, se necessário, é especificado após os parâmetros.
    */
    fun hello(name: String = "world"): String {
        return "Hello, $name!"
    }
    println(hello("foo")) // => Hello, foo!
    println(hello(name = "bar")) // => Hello, bar!
    println(hello()) // => Hello, world!

    /*
    Para que uma função receba um número variável de parâmetros podemos
    marcar um, e apenas um, parâmetro com a palavra-chave "vararg".
    */
    fun varargExample(vararg names: Int) {
        println("Argument has ${names.size} elements")
    }
    varargExample() // => A chamada à função tem 0 argumentos
    varargExample(1) // => A chamada à função tem 1 argumentos
    varargExample(1, 2, 3) // => A chamada à função tem 3 argumentos

    /*
    Quando uma função consiste em apenas uma expressão as chavetas podem ser omitidas
    O corpo da mesma é especificado após o símbolo de igual (=).
    */
    fun odd(x: Int): Boolean = x % 2 == 1
    println(odd(6)) // => false
    println(odd(7)) // => true

    // Se o tipo de retorno da função pode ser inferido então não é necessário especificá-lo.
    fun even(x: Int) = x % 2 == 0
    println(even(6)) // => true
    println(even(7)) // => false

    // As funções podem ter outras funções como parâmetros e/ou como retorno.
    fun not(f: (Int) -> Boolean): (Int) -> Boolean {
        return {n -> !f.invoke(n)}
    }
    // O operador :: pode ser usado para referênciar funções existentes.
    val notOdd = not(::odd)
    val notEven = not(::even)
    /*
    Expressões lambda podem ser usadas da seguinte forma.
    Os lambdas quando passados a outras funções podem estar 
    fora dos parênteses da chamada, caso sejam o último parâmetro.
    */
    val notZero = not {n -> n == 0}
    /*
    Se o lambda apenas tiver um parâmetro então a sua
    declaração pode ser omitida (em conjunto com "->").
    O nome por omissão do parâmetro será "it".
    */
    val notPositive = not {it > 0}
    for (i in 0..4) {
        println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}")
    }

    // Para declararmos classes usa-se a palavra-chave "class".
    class ExampleClass(val x: Int) {
        fun aMethod(y: Int): Int {
            return x + y
        }

        infix fun infixMemberFunction(y: Int): Int {
            return x * y
        }
    }
    /*
    Para se instanciar uma classe usamos o constructor.
    De notar que em Kotlin não existe a palavra-chave "new" como no Java.
    */
    val fooExampleClass = ExampleClass(7)
    // Os métodos da classe podem então ser chamados usando o ponto.
    println(fooExampleClass.aMethod(4)) // => 11
    /*
    Uma função marcada com a palavra-chave "infix" pode ser chamada
    usando a notação infixa.
    */
    println(fooExampleClass infixMemberFunction 4) // => 28

    /*
    Data classes são uma forma concisa de criar classes que apenas contêm dados.
    Neste tipo de classes os métodos "hashCode"/"equals" e "toString" são gerados
    automáticamente.
    */
    data class DataClassExample (val x: Int, val y: Int, val z: Int)
    val fooData = DataClassExample(1, 2, 4)
    println(fooData) // => DataClassExample(x=1, y=2, z=4)

    // Instâncias deste tipo de classes têm acesso ao método "copy".
    val fooCopy = fooData.copy(y = 100)
    println(fooCopy) // => DataClassExample(x=1, y=100, z=4)

    // Os objectos podem ser desconstruídos para variáveis.
    val (a, b, c) = fooCopy
    println("$a $b $c") // => 1 100 4

    // desconstrucção dentro de um ciclo "for"
    for ((a, b, c) in listOf(fooData)) {
        println("$a $b $c") // => 1 2 4
    }

    val mapData = mapOf("a" to 1, "b" to 2)
    // Instâncias de Map.Entry podem também ser desconstruídas.
    for ((key, value) in mapData) {
        println("$key -> $value")
    }

    // A função "with" é semelhante ao bloco "with" do JavaScript.
    data class MutableDataClassExample (var x: Int, var y: Int, var z: Int)
    val fooMutableData = MutableDataClassExample(7, 4, 9)
    with (fooMutableData) {
        x -= 2
        y += 2
        z--
    }
    println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8)

    /*
    Podemos criar listas usando a função "listOf".
    No Kotlin, por padrão, as listas são imútaveis - não podendo 
    assim adicionar ou remover elementos das mesmas.
    */
    val fooList = listOf("a", "b", "c")
    println(fooList.size) // => 3
    println(fooList.first()) // => a
    println(fooList.last()) // => c
    // Os elementos de uma lista podem ser acedidos usando o seu índice.
    println(fooList[1]) // => b

    // Listas mútaveis podem ser criadas usando a função "mutableListOf".
    val fooMutableList = mutableListOf("a", "b", "c")
    fooMutableList.add("d")
    println(fooMutableList.last()) // => d
    println(fooMutableList.size) // => 4

    // Podemos criar conjuntos usando a função "setOf".
    val fooSet = setOf("a", "b", "c")
    println(fooSet.contains("a")) // => true
    println(fooSet.contains("z")) // => false

    // Podemos criar mapas usando a função "mapOf" e através da função infixa "to".
    val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
    // Os valores do mapa podem ser acedidos usando a sua chave.
    println(fooMap["a"]) // => 8

    /*
    No Kotlin as sequências representam collecções de dados avaliadas de forma lazy.
    Podemos cirar uma sequência usando a função "generateSequence".
    */
    val fooSequence = generateSequence(1, { it + 1 })
    val x = fooSequence.take(10).toList()
    println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    // Um exemplo de uso das sequências para gerar os números de Fibonacci:
    fun fibonacciSequence(): Sequence<Long> {
        var a = 0L
        var b = 1L

        fun next(): Long {
            val result = a + b
            a = b
            b = result
            return a
        }

        return generateSequence(::next)
    }
    val y = fibonacciSequence().take(10).toList()
    println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

    // O Kotlin fornece funções de ordem superior convenientes para a manipulação de colecções.
    val z = (1..9).map {it * 3}
                  .filter {it < 20}
                  .groupBy {it % 2 == 0}
                  .mapKeys {if (it.key) "even" else "odd"}
    println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]}

    // Um ciclo "for" pode ser usado com qualquer coisa que forneça um iterador.
    for (c in "hello") {
        println(c)
    }

    // Um ciclo "while" funciona da mesma forma que em outras linguagens.
    var ctr = 0
    while (ctr < 5) {
        println(ctr)
        ctr++
    }
    do {
        println(ctr)
        ctr++
    } while (ctr < 10)

    /*
    Um "if" pode ser usado como uma expressão que produz um valor.
    Por esta razão o operador ternário não é necessário no Kotlin.
    */
    val num = 5
    val message = if (num % 2 == 0) "even" else "odd"
    println("$num is $message") // => 5 is odd

    // O bloco "when" pode ser usado como alternativa para cadeias de "if-else if".
    val i = 10
    when {
        i < 7 -> println("first block")
        fooString.startsWith("hello") -> println("second block")
        else -> println("else block")
    }

    // O "when" pode ser usado como um "switch" do Java.
    when (i) {
        0, 21 -> println("0 or 21")
        in 1..20 -> println("in the range 1 to 20")
        else -> println("none of the above")
    }

    // O "when" pode também ser usado como expressão para produzir um valor.
    var result = when (i) {
        0, 21 -> "0 or 21"
        in 1..20 -> "in the range 1 to 20"
        else -> "none of the above"
    }
    println(result)

    /*
    Podemos utilizar o operador "is" para verificar se um objecto é de um certo tipo.
    Se um objecto passar a verificação do tipo pode ser usado como sendo desse tipo
    sem conversão explicita, sendo isto chamado de smart cast.
    */
    fun smartCastExample(x: Any) : Boolean {
        if (x is Boolean) {
            // x is automatically cast to Boolean
            return x
        } else if (x is Int) {
            // x is automatically cast to Int
            return x > 0
        } else if (x is String) {
            // x is automatically cast to String
            return x.isNotEmpty()
        } else {
            return false
        }
    }
    println(smartCastExample("Hello, world!")) // => true
    println(smartCastExample("")) // => false
    println(smartCastExample(5)) // => true
    println(smartCastExample(0)) // => false
    println(smartCastExample(true)) // => true

    // Os smart casts funcionam também com o bloco "when".
    fun smartCastWhenExample(x: Any) = when (x) {
        is Boolean -> x
        is Int -> x > 0
        is String -> x.isNotEmpty()
        else -> false
    }

    /*
    Extensões são uma forma de adicionar funcionalidade a classes existentes.
    Isto é semelhante aos métodos de extensão do C#.
    */
    fun String.remove(c: Char): String {
        return this.filter {it != c}
    }
    println("Hello, world!".remove('l')) // => Hello, world!
}

// Enum classes são o equivalente aos tipos enum do Java.
enum class EnumExample {
    A, B, C // As constantes da enumeração são separadas por vírgula.
}
fun printEnum() = println(EnumExample.A) // => A

/*
Como cada constante é uma instância da classe enum, 
estas podem ser inicializadas da seguinte forma:
*/
enum class EnumExample(val value: Int) {
    A(value = 1),
    B(value = 2),
    C(value = 3)
}
fun printProperty() = println(EnumExample.A.value) // => 1

/*
Cada constante de enumerações tem propriedades para 
obter o nome e o ordinal (posição) na respectiva classe.
*/
fun printName() = println(EnumExample.A.name) // => A
fun printPosition() = println(EnumExample.A.ordinal) // => 0

/*
A palavra-chave "object" pode ser usada para criar objectos singleton.
Estes não podem ser instânciados, porém podem ser referênciados como uma
única instância através do seu nome.
São semelhantes aos objectos singleton do Scala.
*/
object ObjectExample {
    fun hello(): String {
        return "hello"
    }

    override fun toString(): String {
        return "Hello, it's me, ${ObjectExample::class.simpleName}"
    }
}


fun useSingletonObject() {
    println(ObjectExample.hello()) // => hello
    // Em Kotlin o tipo "Any" é a raíz da hierárquia de classes, tal como o tipo "Object" em Java.
    val someRef: Any = ObjectExample
    println(someRef) // => Hello, it's me, ObjectExample
}


/* 
O operador !! serve para realizar um assert de not-null. Este converte qualquer 
valor nullable para non-null ou lança exceção se o mesmo for null.
*/
var b: String? = "abc"
val l = b!!.length  // lançaria exceção caso "b" fosse null

// O modificador "operator" permite fazer overload dos operadores 
// [Ver lista de operadores](https://kotlinlang.org/docs/operator-overloading.html)
data class Counter(var value: Int) {
    // overload para Counter += Int
    operator fun plusAssign(increment: Int) {
        this.value += increment
    }

    // overload para Counter++ e ++Counter
    operator fun inc() = Counter(value + 1)

    // overload para Counter + Counter
    operator fun plus(other: Counter) = Counter(this.value + other.value)

    // overload para Counter * Counter
    operator fun times(other: Counter) = Counter(this.value * other.value)

    // overload para Counter * Int
    operator fun times(value: Int) = Counter(this.value * value)

    // overload para Counter in Counter
    operator fun contains(other: Counter) = other.value == this.value

    // overload para Counter[Int] = Int
    operator fun set(index: Int, value: Int) {
        this.value = index + value
    }

    // overload para invocação da instância Counter
    operator fun invoke() = println("The value of the counter is $value")
}
/* Podemos também dar overload dos operadores através de métodos de extensão */
// overload para -Counter
operator fun Counter.unaryMinus() = Counter(-this.value)

fun operatorOverloadingDemo() {
    var counter1 = Counter(0)
    var counter2 = Counter(5)
    counter1 += 7
    println(counter1) // => Counter(value=7)
    println(counter1 + counter2) // => Counter(value=12)
    println(counter1 * counter2) // => Counter(value=35)
    println(counter2 * 2) // => Counter(value=10)
    println(counter1 in Counter(5)) // => false
    println(counter1 in Counter(7)) // => true
    counter1[26] = 10
    println(counter1) // => Counter(value=36)
    counter1() // => The value of the counter is 36
    println(-counter2) // => Counter(value=-5)
}

Leituras Adicionais


Tens alguma sugestão? Uma correção, talvez? Abre um Issue no repositório do Github, or faz um pull request tu mesmo!

Originalmente contribuido por S Webber, e atualizado por 0 contribuidor(es).