summaryrefslogtreecommitdiffhomepage
path: root/pt-br
diff options
context:
space:
mode:
Diffstat (limited to 'pt-br')
-rw-r--r--pt-br/kotlin-pt.html.markdown384
1 files changed, 384 insertions, 0 deletions
diff --git a/pt-br/kotlin-pt.html.markdown b/pt-br/kotlin-pt.html.markdown
new file mode 100644
index 00000000..7c3313fc
--- /dev/null
+++ b/pt-br/kotlin-pt.html.markdown
@@ -0,0 +1,384 @@
+---
+language: kotlin
+filename: LearnKotlin-pt.kt
+contributors:
+ - ["S Webber", "https://github.com/s-webber"]
+translators:
+ - ["Márcio Torres", "https://github.com/marciojrtorres"]
+lang: pt-br
+---
+
+Kotlin é uma linguagem de programação estaticamente tipada para a JVM, Android e navegadores web. Ela é 100% interoperável com Java.
+[Leia mais aqui.](https://kotlinlang.org/)
+
+```kotlin
+// Comentários de uma linha iniciam com //
+/*
+Comentários multilinha se parecem com este.
+*/
+
+// A palavra-chave "package" funciona do mesmo modo que no Java.
+package com.learnxinyminutes.kotlin
+
+/*
+O ponto de entrada para um programa em Kotlin é uma função chamada "main"
+Esta função recebe um vetor contendo quaisquer argumentos da linha de comando
+*/
+fun main(args: Array<String>) {
+ /*
+ A declaração de valores pode ser feita tanto com "var" como "val"
+ Declarações com "val" não podem ser reatribuídas, enquanto com "var" podem.
+ */
+ val umVal = 10 // não se poderá reatribuir qualquer coisa a umVal
+ var umVar = 10
+ umVar = 20 // umVar pode ser reatribuída, mas respeitando o tipo
+
+ /*
+ Na maioria dos casos Kotlin pode inferir o tipo, então não é preciso sempre
+ especificar o tipo explicitamente, mas quando o fazemos é assim:
+ */
+ val umInteiro: Int = 7
+
+ /*
+ Strings podem ser representadas de forma semelhante a Java.
+ A contrabarra realiza o "escape", da mesma forma.
+ */
+ val umaString = "Minha String está aqui!"
+ val outraString = "Imprimir na outra linha?\nSem problema!"
+ val maisString = "Você quer adicionar um tab?\tSem problema!"
+ println(umaString)
+ println(outraString)
+ println(maisString)
+
+ /*
+ Uma string bruta é delimitada com três aspas (""").
+ Strings brutas podem conter novas linhas e outros caracteres.
+ */
+ val umaStringBruta = """
+fun olaMundo(val nome : String) {
+ println("Olá, mundo!")
+}
+"""
+ println(umaStringBruta)
+
+ /*
+ As strings podem conter expressões modelo (template).
+ Uma expressão modelo começa com um cifrão ($).
+ É semelhante à interpolação de Strings em Ruby.
+ */
+ val umaStringModelo = "$umaString tem ${umaString.length} caracteres"
+ println(umaStringModelo)
+
+ /*
+ Para uma variável receber null deve-se explicitamente declara-la
+ como anulável.
+ A declaração de anulável é realizada incluindo uma "?" ao fim do tipo.
+ Pode-se acessar uma variável anulável usando o operador "?."
+ Usa-se o operador "?:" (também conhecido como operador Elvis) para
+ atribuir um valor alternativo para quando uma variável é nula.
+ */
+ var umaVariavelAnulavel: String? = "abc"
+ println(umaVariavelAnulavel?.length) // => 3
+ println(umaVariavelAnulavel?.length ?: -1) // => 3
+ umaVariavelAnulavel = null
+ println(umaVariavelAnulavel?.length) // => null
+ println(umaVariavelAnulavel?.length ?: -1) // => -1
+
+ /*
+ Funções podem ser declaradas usando a palavra-chave "fun"
+ Os parâmetros da função são declarados entre parênteses logo
+ após o nome da função.
+ Os parâmetros da função podem ter opcionalmente um valor padrão.
+ O tipo de retorno da função, se necessário, é especificado após os argumentos.
+ */
+ fun ola(nome: String = "mundo"): String {
+ return "Olá, $nome!"
+ }
+ println(ola("você")) // => Olá, você!
+ println(ola(nome = "tu")) // => Olá, tu!
+ println(ola()) // => Olá, mundo!
+
+ /*
+ Um parâmetro pode ser declarado com a palavra-chave "vararg" para
+ permitir que seja passado um número variável de argumentos.
+ */
+ fun exemploVarArg(vararg numeros: Int) {
+ println("Foram recebidos ${numeros.size} argumentos")
+ }
+ exemploVarArg() // => Passando nenhum argumento (0 argumentos)
+ exemploVarArg(1) // => Passando 1 argumento
+ exemploVarArg(1, 2, 3) // => Passando 3 argumentos
+
+ /*
+ Quando uma função consiste numa única expressão as chaves
+ podem ser omitidas e o corpo declarado após o símbolo de "="
+ */
+ fun impar(x: Int): Boolean = x % 2 == 1
+ println(impar(6)) // => false
+ println(impar(7)) // => true
+
+ // O tipo de retorno não precisa ser declarado se pode ser inferido.
+ fun impar(x: Int) = x % 2 == 0
+ println(impar(6)) // => true
+ println(impar(7)) // => false
+
+ // Funções podem receber e retornar outras funções
+ fun nao(f: (Int) -> Boolean): (Int) -> Boolean {
+ return {n -> !f.invoke(n)}
+ }
+ // Funções nomeadas podem ser passadas como argumento usando o operador "::"
+ val naoImpar = nao(::impar)
+ val naoPar = nao(::par)
+ // Expressões Lambda podem ser usadas como argumentos
+ val naoZero = nao {n -> n == 0}
+ /*
+ Se uma lambda têm apenas um parâmetro sua declaração pode ser omitida,
+ incluindo o símbolo "->".
+ Neste caso o nome do único parâmetro deve ser "it".
+ */
+ val naoPositivo = nao {it > 0}
+ for (i in 0..4) {
+ println("${naoImpar(i)} ${naoPar(i)} ${naoZero(i)} ${naoPositivo(i)}")
+ }
+
+ // A palavra-chave "class" é usada para declarar classes
+ class ClasseExemplo(val x: Int) {
+ fun funcaoMembro(y: Int): Int { // ou "método"
+ return x + y
+ }
+
+ infix fun funcaoMembroInfixa(y: Int): Int {
+ return x * y
+ }
+ }
+ /*
+ Para criar uma nova instância chama-se o construtor.
+ Note que Kotlin não tem a palavra-chave "new".
+ */
+ val umaInstanciaDaClasseExemplo = ClasseExemplo(7)
+ // Funções membro (métodos) podem ser chamados usando a notação ponto "."
+ println(umaInstanciaDaClasseExemplo.funcaoMembro(4)) // => 11
+ /*
+ Se uma função foi declarada com a palavra-chave "infix" então
+ ela pode ser invocada com a notação infixa.
+ */
+ println(umaInstanciaDaClasseExemplo funcaoMembroInfixa 4) // => 28
+
+ /*
+ Classes de dados são um modo sucinto de criar classes que servem apenas
+ para guardas informações.
+ Os métodos "hashCode", "equals" e "toString" são gerados automaticamente.
+ */
+ data class ExemploClasseDados (val x: Int, val y: Int, val z: Int)
+ val objetoDados = ExemploClasseDados(1, 2, 4)
+ println(objetoDados) // => ExemploClasseDados(x=1, y=2, z=4)
+
+ // Classes de dados têm uma função "copy"
+ val dadosCopia = objetoDados.copy(y = 100)
+ println(dadosCopia) // => ExemploClasseDados(x=1, y=100, z=4)
+
+ // Objetos podem ser desestruturados em múltiplas variáveis.
+ val (a, b, c) = dadosCopia
+ println("$a $b $c") // => 1 100 4
+
+ // desestruturando em um laço "for"
+ for ((a, b, c) in listOf(objetoDados)) {
+ println("$a $b $c") // => 1 100 4
+ }
+
+ val mapaDados = mapOf("a" to 1, "b" to 2)
+ // Map.Entry também é desestruturável
+ for ((chave, valor) in mapaDados) {
+ println("$chave -> $valor")
+ }
+
+ // A função "with" é semelhante à declaração "with" do JavaScript
+ data class ExemploClasseDadosMutaveis (var x: Int, var y: Int, var z: Int)
+ val objDadosMutaveis = ExemploClasseDadosMutaveis(7, 4, 9)
+ with (objDadosMutaveis) {
+ x -= 2
+ y += 2
+ z--
+ }
+ println(objDadosMutaveis) // => ExemploClasseDadosMutaveis(x=5, y=6, z=8)
+
+ /*
+ Pode-se criar uma lista usando a função "listOf".
+ A lista é imutável, isto é, elementos não podem ser adicionados ou removidos.
+ */
+ val umaLista = listOf("a", "b", "c")
+ println(umaLista.size) // => 3
+ println(umaLista.first()) // => a
+ println(umaLista.last()) // => c
+ // Elementos de uma lista podem ser acessados pelo índice
+ println(umaLista[1]) // => b
+
+ // Uma lista mutável pode ser criada com a função "mutableListOf".
+ val umaListaMutavel = mutableListOf("a", "b", "c")
+ umaListaMutavel.add("d")
+ println(umaListaMutavel.last()) // => d
+ println(umaListaMutavel.size) // => 4
+
+ // Similarmente, pode-se criar um conjunto com a função "setOf".
+ val umConjunto = setOf("a", "b", "c")
+ println(umConjunto.contains("a")) // => true
+ println(umConjunto.contains("z")) // => false
+
+ // Da mesma forma que um mapa com a função "mapOf".
+ val umMapa = mapOf("a" to 8, "b" to 7, "c" to 9)
+ // Os valores contidos no mapa podem ser acessados pela sua chave.
+ println(umMapa["a"]) // => 8
+
+ /*
+ Sequências representam coleções avaliadas "preguiçosamente" (sob demanda).
+ Pode-se criar uma sequência usando a função "generateSequence".
+ */
+ val umaSequencia = generateSequence(1, { it + 1 })
+ val x = umaSequencia.take(10).toList()
+ println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+ // Um exemplo de uma sequência usada para gerar Números de Fibonacci:
+ fun sequenciaFibonacci(): Sequence<Long> {
+ var a = 0L
+ var b = 1L
+
+ fun proximo(): Long {
+ val resultado = a + b
+ a = b
+ b = resultado
+ return a
+ }
+
+ return generateSequence(::proximo)
+ }
+ val y = sequenciaFibonacci().take(10).toList()
+ println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+
+ // Kotlin oferece funções de alta-ordem para trabalhar com coleções.
+ val z = (1..9).map {it * 3}
+ .filter {it < 20}
+ .groupBy {it % 2 == 0}
+ .mapKeys {if (it.key) "par" else "impar"}
+ println(z) // => {impar=[3, 9, 15], par=[6, 12, 18]}
+
+ // Um "for" pode ser usado com qualquer coisa que ofereça um "iterator"
+ for (c in "salve") {
+ println(c)
+ }
+
+ // O "while" funciona da mesma forma que em outras linguagens.
+ var contador = 0
+ while (contador < 5) {
+ println(contador)
+ contador++
+ }
+ do {
+ println(contador)
+ contador++
+ } while (contador < 10)
+
+ /*
+ "if" pode ser usado como uma expressão que retorna um valor.
+ Por este motivo o operador ternário "? :" não é necessário em Kotlin.
+ */
+ val numero = 5
+ val mensagem = if (numero % 2 == 0) "par" else "impar"
+ println("$numero é $mensagem") // => 5 é impar
+
+ // "when" pode ser usado como alternativa às correntes de "if-else if".
+ val i = 10
+ when {
+ i < 7 -> println("primeiro block")
+ umaString.startsWith("oi") -> println("segundo block")
+ else -> println("bloco else")
+ }
+
+ // "when" pode ser usado com um argumento.
+ when (i) {
+ 0, 21 -> println("0 ou 21")
+ in 1..20 -> println("entre 1 e 20")
+ else -> println("nenhum dos anteriores")
+ }
+
+ // "when" pode ser usada como uma função que retorna um valor.
+ var resultado = when (i) {
+ 0, 21 -> "0 ou 21"
+ in 1..20 -> "entre 1 e 20"
+ else -> "nenhum dos anteriores"
+ }
+ println(resultado)
+
+ /*
+ Pode-se verificar se um objeto é de um certo tipo usando o operador "is".
+ Se o objeto passar pela verificação então ele pode ser usado como
+ este tipo, sem a necessidade de uma coerção (cast) explícita (SmartCast).
+ */
+ fun exemploSmartCast(x: Any) : Boolean {
+ if (x is Boolean) {
+ // x é automaticamente coagido para Boolean
+ return x
+ } else if (x is Int) {
+ // x é automaticamente coagido para Int
+ return x > 0
+ } else if (x is String) {
+ // x é automaticamente coagido para String
+ return x.isNotEmpty()
+ } else {
+ return false
+ }
+ }
+ println(exemploSmartCast("Olá, mundo!")) // => true
+ println(exemploSmartCast("")) // => false
+ println(exemploSmartCast(5)) // => true
+ println(exemploSmartCast(0)) // => false
+ println(exemploSmartCast(true)) // => true
+
+ // O Smartcast também funciona com blocos "when"
+ fun exemploSmartCastComWhen(x: Any) = when (x) {
+ is Boolean -> x
+ is Int -> x > 0
+ is String -> x.isNotEmpty()
+ else -> false
+ }
+
+ /*
+ As extensões são uma maneira nova de adicionar funcionalidades a classes.
+ Elas são similares aos "extension methods" da linguagem C#.
+ */
+ fun String.remove(c: Char): String {
+ return this.filter {it != c}
+ }
+ println("olá, mundo!".remove('o')) // => lá, mund!
+
+ println(ExemploEnum.A) // => A
+ println(ExemploObjeto.ola()) // => olá
+}
+
+// Classes Enum são similares aos "enum types" do Java.
+enum class ExemploEnum {
+ A, B, C
+}
+
+/*
+A palavra-chave "object" pode ser usar para criar Singletons.
+Eles não são instanciados, mas podem referenciar sua instância única pelo nome.
+É semelhante aos "singleton objects" da linguagem Scala.
+*/
+object ExemploObjeto {
+ fun ola(): String {
+ return "olá"
+ }
+}
+
+fun usaObjeto() {
+ ExemploObjeto.ola()
+ val algumaReferencia: Any = ExemploObjeto // usa-se o nome diretamente
+}
+
+```
+
+### Leitura Adicional
+
+* [Tutoriais de Kotlin](https://kotlinlang.org/docs/tutorials/)(EN)
+* [Experimente Kotlin no seu navegador](http://try.kotlinlang.org/)(EN)
+* [Uma lista de material sobre Kotlin](http://kotlin.link/)(EN)