mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 17:41:41 +00:00
472 lines
15 KiB
Markdown
472 lines
15 KiB
Markdown
---
|
|
filename: LearnKotlin-pt.kt
|
|
contributors:
|
|
- ["S Webber", "https://github.com/s-webber"]
|
|
translators:
|
|
- ["André Martins", "https://github.com/chriptus13"]
|
|
---
|
|
|
|
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.](https://kotlinlang.org/)
|
|
|
|
```kotlin
|
|
// 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
|
|
|
|
* [Tutoriais de Kotlin](https://kotlinlang.org/docs/tutorials/)
|
|
* [Experimenta Kotlin no browser](https://play.kotlinlang.org/)
|
|
* [Recursos adicionais](http://kotlin.link/)
|