Stephen Samuel Stefan Bocutiu
Novatec
Copyright © Packt Publishing 2017. First published in the English language under the title ‘Programming Kotlin (9781787126367)’. Copyright © Packt Publishing 2017. Publicação original em inglês intitulada ‘Programming Kotlin (9781787126367)’. Esta tradução é publicada e vendida com a permissão da Packt Publishing. © Novatec Editora Ltda. 2017. Todos os direitos reservados e protegidos pela Lei 9.610 de 19/02/1998. É proibida a reprodução desta obra, mesmo parcial, por qualquer processo, sem prévia autorização, por escrito, do autor e da Editora. Editor: Rubens Prates OG20170914 Tradução: Lúcia A. Kinoshita Revisão gramatical: Patrizia Zagni Editoração eletrônica: Carolina Kuwabata ISBN: 978-85-7522-605-6 Histórico de impressões: Setembro/2017
Primeira edição
Novatec Editora Ltda. Rua Luís Antônio dos Santos 110 02460-000 – São Paulo, SP – Brasil Tel.: +55 11 2959-6529 Email: novatec@novatec.com.br Site: www.novatec.com.br Twitter: twitter.com/novateceditora Facebook: facebook.com/novatec LinkedIn: linkedin.com/in/novatec
capítulo 1
Introdução à linguagem Kotlin
É hora de escrever código. Neste capítulo, veremos como escrever um código típico, que é o ponto de entrada para toda linguagem: o famoso Hello World!. Para isso, precisaremos configurar o ambiente inicial necessário para desenvolver software com Kotlin. Apresentaremos alguns exemplos usando o compilador a partir da linha de comando e, em seguida, prosseguiremos com o modo usual de programar utilizando os IDEs e as ferramentas de construção disponíveis. Kotlin é uma linguagem JVM, portanto o compilador gerará bytecodes Java. Por causa disso, é claro, o código Kotlin poderá chamar código Java e vice-versa! Assim, será necessário ter o Java JDK instalado em sua máquina. Para ser capaz de escrever código para Android, no qual a versão mais recente aceita é a Java 6, o compilador deve traduzir seu código para bytecodes que sejam, no mínimo, compatíveis com Java 6. Neste livro, porém, todos os exemplos de código serão executados com Java JDK 8. Se o mundo da JVM for novidade para você, obtenha a versão mais recente de Java em http://www.oracle.com/technetwork/java/javase/downloads/index.html. Neste capítulo, você aprenderá a: • usar a linha de comando para compilar e executar código escrito em Kotlin; • usar o REPL e escrever scripts Kotlin; • criar um projeto Gradle com Kotlin ativado; • criar um projeto Maven com Kotlin ativado; • usar o IntelliJ para criar um projeto Kotlin; • usar o IDE Eclipse para criar um projeto Kotlin; • misturar código Kotlin e Java ao mesmo projeto.
20
Capítulo 1 ■ Introdução à linguagem Kotlin
21
Usando a linha de comando para compilar e executar código Kotlin Para escrever e executar código escrito em Kotlin, você precisará de seu runtime e do compilador. Quando escrevemos este livro, a versão 1.1 milestone 4 estava disponível (a versão estável é 1.0.6). Toda versão de runtime vem com sua própria versão de compilador. Para obtê-la, acesse https://github.com/JetBrains/kotlin/releases/ tag/v1.1-M04, faça rolagens até a parte inferior da página, baixe e descompacte o arquivo ZIP kotlin-compiler-1.1-M04.zip em um local conhecido em sua máquina. A pasta resultante conterá uma subpasta bin com todos os scripts necessários para compilar e executar Kotlin em Windows, Linux ou OS X. Contudo, você deve garantir que a localização da pasta bin faça parte do PATH de seu sistema para poder chamar kotlinc sem ter que especificar o path completo. Se sua máquina executa Linux ou OS X, há uma maneira mais fácil de instalar o compilador usando sdkman. Tudo que você precisa fazer é executar os comandos a seguir em um terminal: $ curl -s https://get.sdkman.io | bash $ bash $ sdk install kotlin 1.1-M04
Como alternativa, se você estiver usando OS X e tiver o homebrew instalado, poderá executar os comandos a seguir para obter o mesmo resultado: $ brew update $ brew install kotlin@1.1-M04
Agora que tudo isso foi feito, podemos finalmente escrever nosso primeiro código em Kotlin. A aplicação que escreveremos não faz nada além de exibir o texto Hello World! no console. Comece criando um novo arquivo chamado HelloWorld.kt e digite o seguinte: fun main(args: Array<String>) { println("Hello, World!") }
A partir da linha de comando, chame o compilador para gerar o assembly JAR (include-runtime é uma flag para o compilador gerar um JAR autocontido e executável que inclua o runtime de Kotlin no assembly resultante): kotlinc HelloWorld.kt -include-runtime -d HelloWorld.jar
22
Programando com Kotlin
Agora, você está pronto para executar o seu programa digitando o comando a seguir na linha de comando; estamos supondo que seu JAVA_HOME está configurado e foi adicionado ao path do sistema: $ java -jar HelloWorld.jar
O código é bem simples. Ele define a função que é o ponto de entrada de seu programa; na primeira e única linha de código, o texto é exibido no console. Se você já trabalhou com as linguagens Java ou Scala, talvez esteja levantando uma sobrancelha, pois deverá ter percebido a falta da classe típica que geralmente definiria o ponto de entrada-padrão do programa, que é a função static principal. Como isso funciona então? Veremos o que realmente acontece. Em primeiro lugar, vamos simplesmente compilar o código anterior executando o comando a seguir. Uma HelloWorld.class será criada na mesma pasta: $ kotlinc HelloWorld.kt
Agora que temos o bytecode gerado, vamos observá-lo usando a ferramenta javap que acompanha o JDK (por favor, note que o nome do arquivo contém um sufixo Kt): $ javap -c HelloWorldKt.class
Depois que a execução terminar, você deverá ver os dados a seguir exibidos em seu terminal: Compiled from "HelloWorld.kt" public final class HelloWorldKt { public static final void main(java.lang.String[]); Code: 0: aload_0 1: ldc #9 // String args 3: invokestatic #15 // Method kotlin/jvm/internal/Intrinsics. checkParameterIsNotNull:(Ljava/lang/Object;Ljava/lang/String;)V 6: ldc #17 // String Hello, World! 8: astore_1 9: nop 10: getstatic #23 // Field java/lang/System.out:Ljava/io/PrintStream; 13: aload_1 14: invokevirtual #29 // Method java/io/PrintStream.println:(Ljava/lang/ Object;)V 17: return }
Capítulo 1 ■ Introdução à linguagem Kotlin
23
Não é preciso ser um expert em bytecode para entender o que o compilador realmente fez por nós. Como podemos ver nesse trecho de código, uma classe foi gerada e contém o ponto de entrada do programa com instruções para exibir Hello World! no console. Não esperamos que você trabalhe com o compilador na linha de comando no cotidiano; em vez disso, você deverá usar ferramentas que estarão à sua disposição para delegar essa tarefa, como veremos em breve.
Runtime de Kotlin Quando compilamos Hello World! e geramos o JAR, instruímos o compilador a incluir o runtime de Kotlin. Por que o runtime é necessário? Observe com mais atenção o bytecode gerado, caso ainda não o tenha feito. Para sermos mais específicos, observe a linha 3. Ela chama um método para validar se a variável args não é null; assim, se você compilar o código sem pedir que o runtime seja incluído e tentar executá-lo, uma exceção será gerada: $ kotlinc HelloWorld.kt -d HelloWorld.jar $ java -jar HelloWorld.jar Exception in thread "main" java.lang.NoClassDefFoundError: kotlin/jvm/internal/Intrinsics at HelloWorldKt.main(HelloWorld.kt) Caused by: java.lang.ClassNotFoundException: kotlin.jvm.internal.Intrinsics
O consumo de memória do runtime é bem baixo; com ~800 K, não há desculpas. Kotlin vem com sua própria biblioteca-padrão de classes (Kotlin runtime), que é diferente da biblioteca Java. Como resultado, é preciso combiná-la com o JAR resultante (fazer um merge) ou especificá-la no classpath: $ java -cp $KOTLIN_HOME/lib/kotlin-runtime.jar:HelloWorld.jar HelloWorldKt
Se você desenvolver uma biblioteca para uso exclusivo de outras bibliotecas ou aplicações Kotlin, não será necessário incluir o runtime. Como alternativa, há um caminho mais curto. Nessa opção, uma flag é passada para o compilador de Kotlin: $kotlinc -include-runtime HelloWorld.kt -d HelloWorld
24
Programando com Kotlin
REPL Atualmente, a maioria das linguagens oferece um shell interativo, e Kotlin não é exceção. Se quiser escrever rapidamente um código que não será usado novamente, o REPL será uma boa ferramenta para ter. Algumas pessoas preferem testar rapidamente seus métodos, mas você sempre deve escrever testes de unidade (unit tests) em vez de usar o REPL para validar se a saída está correta. O REPL pode ser iniciado adicionando dependências ao classpath a fim de deixá-las disponíveis para a instância. Para dar um exemplo, usaremos a biblioteca Joda para lidar com data e hora. Inicialmente, devemos fazer download do JAR. Em uma janela do terminal, utilize os comandos a seguir: $ wget https://github.com/JodaOrg/joda-time/releases/download/v2.9.4/joda-time-2.9 .4-dist.tar.gz $ tar xvf joda-time-2.9.4-dist.tar.gz
Agora que você está pronto para iniciar o REPL, associe a biblioteca Joda à sua instância em execução, importe e utilize as classes que ela oferece: $ kotlinc-jvm -cp joda-time-2.9.4/joda-time-2.9.4.jar Welcome to Kotlin version 1.1-M04 (JRE 1.8.0_66-internal-b17) Type :help for help, :quit for quit >>> import org.joda.time.DateTime >>> DateTime.now() 2016-08-25T22:53:41.017+01:00
Kotlin para scripting Kotlin também pode ser executado como script. Se você não gosta de bash nem de Perl, agora terá uma alternativa. Suponha que você queira apagar todos os arquivos anteriores a N dias. O exemplo de código a seguir faz exatamente isso: import java.io.File val purgeTime = System.currentTimeMillis() - args[1].toLong() * 24 * 60 * 60 * 1000 val folders = File(args[0]).listFiles { file -> file.isFile } folders ?.filter { file -> file.lastModified() < purgeTime }
Capítulo 1 ■ Introdução à linguagem Kotlin
25
?.forEach { file -> println("Deleting ${file.absolutePath}") file.delete() }
Crie um arquivo chamado delete.kts com o conteúdo anterior. Observe a variável predefinida args, que contém todos os parâmetros de entrada passados à chamada. Você pode estar se perguntando o que o caractere ? está fazendo nesse código. Se você tem familiaridade com a linguagem C# e conhece as classes nullable, então já saberá a resposta. Mesmo que não tenha se deparado antes com esse caractere, tenho certeza de que você tem uma boa noção do que ele faz. O caractere é chamado de operador de chamada segura (safe call operator) e, como você verá mais adiante no livro quando o assunto for discutido com mais detalhes, ele evita o lamentável erro de NullPointerException. O script aceita dois argumentos: a pasta-alvo e o limite para o número de dias. Para cada arquivo encontrado no alvo, o script verificará quando ele foi modificado pela última vez; se o timestamp for menor que o timestamp de purge (expurgo) calculado, o arquivo será apagado. O script anterior não incluiu o tratamento de erro; deixaremos isso como exercício para você. Agora que está disponível, o script poderá ser chamado executando o seguinte: $ kotlinc -script delete.kts . 5
Se você copiar/criar arquivos na pasta atual com um timestamp de última modificação anterior a cinco dias, o script os removerá.
Kotlin com Gradle Se você tem familiaridade com o universo das ferramentas de construção, provavelmente estará em uma de três áreas: Maven, Gradle ou SBT (será mais provável se você for desenvolvedor de Scala). Não entrarei em detalhes, mas apresentaremos o básico sobre Gradle – o sistema de automação de construção moderno, poliglota e de código aberto – e deixaremos que os curiosos obtenham mais informações em http://gradle.org. Antes de prosseguir, por favor, certifique-se de tê-lo instalado e disponível em seu classpath para que ele seja acessível a partir do terminal. Se tiver o SDKMAN, o Gradle poderá ser instalado com o comando a seguir: $ sdk install gradle 3.0
26
Programando com Kotlin
O sistema de construção vem com alguns templates incluídos, embora sejam limitados, e em sua versão 3.0 mais recente, Kotlin ainda não estava incluído. Esperamos que essa deficiência seja resolvida em breve. No entanto, configurar suporte para Kotlin não exige muito. Em primeiro lugar, veremos como podemos consultar os templates disponíveis: $ gradle help --task :init
Você deverá visualizar as seguintes informações exibidas no terminal: Options --type Set type of build to create. Available values are: basic groovy-library java-library pom scala-library
Vamos prosseguir e usar o template Java para criar a estrutura de nosso projeto executando o comando bash a seguir: $ gradle init --type java-library
Esse template gerará um conjunto de arquivos e pastas; se você já usou Maven, verá que essa estrutura é semelhante:
Layout das pastas de projeto.
Da forma como está, o projeto Gradle não está pronto para Kotlin. Inicialmente, apague Library.java e LibraryTest.java e crie uma nova pasta chamada kotlin, que é uma irmã da pasta java. Em seguida, usando um editor de texto, abra o arquivo build.gradle. Precisamos adicionar o plugin que permita ao sistema Gradle compilar código Kotlin para nós, portanto, no início de seu arquivo, acrescente o trecho a seguir:
Capítulo 1 ■ Introdução à linguagem Kotlin
27
buildscript { ext.kotlin_version = '1.1-M04' repositories { maven { url "https://dl.bintray.com/kotlin/kotlin-dev" } mavenCentral() } dependencies { classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" }
As instruções anteriores dizem ao Gradle para usar o plugin para Kotlin e definem o repositório de dependências de maven. Como a versão Kotlin 1.1 está apenas no milestone 4, há um repositório específico do qual ela deverá ser obtida. Observe a última entrada em repositories. Ainda não terminamos; precisamos, ainda, ativar o plugin. O template gerado já terá um plugin aplicado: java. Substitua-o por: apply plugin: 'kotlin' apply plugin: 'application' mainClassName = 'com.programming.kotlin.chapter01.ProgramKt'
Agora o suporte para o plugin de Kotlin está ativado; talvez você tenha percebido que também acrescentamos o plugin application e definimos a classe contendo o ponto de entrada do programa. Fizemos isso para permitir que o programa execute diretamente, como veremos em breve. Ainda não terminamos. Precisamos, ainda, fazer a ligação com a biblioteca-padrão de Kotlin. Substitua as seções repositories e dependencies por: repositories { maven { url "https://dl.bintray.com/kotlin/kotlin-dev" } mavenCentral() } dependencies { compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" testCompile 'io.kotlintest:kotlintest:1.3.3' }
Agora, vamos criar o arquivo chamado HelloWorld.Kt. Desta vez, definiremos um namespace e, desse modo, evitaremos que nossa classe faça parte do namespace default. Se você ainda não tem familiaridade com o termo, não se preocupe; ele será discutido no capítulo 2.
28
Programando com Kotlin
No terminal, execute o seguinte: $ mkdir -p src/main/kotlin/com/programming/kotlin/chapter01 $ echo "" >> src/main/kotlin/com/programming/kotlin/chapter01/Program.kt $ cat <<EOF >> src/main/kotlin/com/programming/kotlin/chapter01/Program.kt package com.programming.kotlin.chapter01 fun main(args: Array<String>) { println("Hello World! ") }
Agora estamos prontos para construir e executar a aplicação: $ gradle build $ gradle run
Queremos executar nosso programa usando java -jar [artefact]. Antes disso, precisamos fazer uma adaptação em build.gradle. Inicialmente, devemos criar um arquivo manifest e definir a classe principal; a JVM procurará a função principal para começar a executá-la: jar { manifest { attributes( 'Main-Class': 'com.programming.kotlin.chapter01.ProgramKt' ) } from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } } }
Além disso, incluímos também a dependência para kotlin-stdlib , bem como kotlin-runtime no JAR. Se essas dependências foram deixadas de fora, será necessário acrescentá-las ao classpath quando a aplicação for executada. Agora você está pronto para construir e executar o código.
Kotlin com Maven Se você preferir se ater ao bom e velho Maven, tudo bem. Há um plugin para que ele aceite Kotlin também. Se você não tiver o Maven em seu computador, poderá seguir as instruções em https://maven.apache.org/install.html para instalá-lo em sua máquina local.
Capítulo 1 ■ Introdução à linguagem Kotlin
29
Assim como fizemos com o Gradle, vamos usar os templates prontos para gerar a pasta de projeto e a estrutura de arquivos. No terminal, em uma pasta totalmente nova, execute o comando a seguir: $ mvn archetype:generate -DgroupId=com.programming.kotlin -DartifactId=chapter01 -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false maven-archetype- quickstart => maven-archetype-quickstart
O arquivo pom.xml e a pasta src para Maven serão gerados. Porém, antes de adicionar o arquivo contendo o código Kotlin, é preciso ativar o plugin. Como fizemos antes, comece apagando App.java e AppTest.java de src/main/java/com/programming/kotlin e src/test/java/com/programming/kotlin e crie a pasta src/main/kotlin (a estrutura de subdiretórios coincide com o nome do namespace): $ mkdir -p src/main/kotlin/com/programming/kotlin/chapter01 $ mkdir -p src/test/kotlin/com/programming/kotlin/chapter01
Em um editor de sua preferência, abra o arquivo pom.xml gerado e acrescente o seguinte: <pluginRepositories> <pluginRepository> <snapshots> <enabled>true</enabled> </snapshots> <id>bintray-kotlin-kotlin-dev</id> <name>bintray</name> <url>http://dl.bintray.com/kotlin/kotlin-dev</url> </pluginRepository> </pluginRepositories> <repositories> <repository> <snapshots> <enabled>true</enabled> </snapshots> <id>bintray-kotlin-kotlin-dev</id> <name>bintray</name> <url>http://dl.bintray.com/kotlin/kotlin-dev</url> </repository> </repositories>
30
Programando com Kotlin <properties> <kotlin.version>1.1-M04</kotlin.version> <kotlin.test.version>1.3.3</kotlin.test.version> </properties> <build> <sourceDirectory>${project.basedir}/src/main/kotlin</sourceDirectory> <testSourceDirectory>${project.basedir}/src/test/kotlin</testSourceDirectory> <plugins> <plugin> <artifactId>kotlin-maven-plugin</artifactId> <groupId>org.jetbrains.kotlin</groupId> <version>${kotlin.version}</version> <executions> <execution> <id>compile</id> <phase>process-sources</phase> <goals> <goal>compile</goal> </goals> </execution> <execution> <id>test-compile</id> <phase>process-test-sources</phase> <goals> <goal>test-compile</goal> </goals> </execution> </executions> </plugin> </plugins> </build>
Tudo o que fizemos até agora foi ativar o plugin de Kotlin e fazê-lo executar na fase de etapas de processo para permitir a mistura de código Java também. Há casos em que você poderá ter partes do código-fonte escritas no bom e velho Java. Tenho certeza de que também percebeu o acréscimo de tags de diretório-fonte, permitindo que arquivos kotlin sejam incluídos na construção. A única tarefa que resta agora é adicionar as dependências de biblioteca para o runtime de Kotlin, assim como para os testes de unidade. Só lidaremos com o framework de testes mais adiante no livro. Substitua toda a seção dependencies pelo seguinte:
Capítulo 1 ■ Introdução à linguagem Kotlin
31
<dependencies> <dependency> <groupId>org.jetbrains.kotlin</groupId> <artifactId>kotlin-stdlib</artifactId> <version>${kotlin.version}</version> </dependency> <dependency> <groupId>io.kotlintest</groupId> <artifactId>kotlintest</artifactId> <version>${kotlin.test.version}</version> <scope>test</scope> </dependency> </dependencies>
É hora de adicionar o código de Hello World!; esse passo é semelhante àquele que executamos antes, quando discutimos o Gradle: $ echo "" >> src/main/kotlin/com/programming/kotlin/chapter01/Program.kt $cat <<EOF >> src/main/kotlin/com/programming/kotlin/chapter01/Program.kt package com.programming.kotlin.chapter01 fun main(args: Array<String>) { println("Hello World!") }
Agora estamos prontos para compilar e construir o arquivo JAR para o programa de exemplo: $ mvn package $ mvn exec:java – Dexec.mainClass="com.programming.kotlin.chapter01.ProgramKt"
A última instrução deve terminar exibindo o texto Hello World! no console. É claro que podemos executar o programa fora do Maven, retornando à execução de Java, mas precisamos adicionar o runtime de Kotlin no classpath: $java -cp $KOTLIN_HOME/lib/kotlin-runtime.jar:target/chapter01-1.0SNAPSHOT.jar "com.programming.kotlin.chapter01.ProgramKt"
Se quiser evitar a configuração da dependência de Classpath ao executar a aplicação, há uma opção para incluir todas as dependência no JAR resultante e gerar o que é chamado de fat jar. Para isso, porém, é necessário acrescentar outro plugin:
32
Programando com Kotlin <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-shade-plugin</artifactId> <version>2.4.3</version> <executions> <execution> <phase>package</phase> <goals> <goal>shade</goal> </goals> <configuration> <transformers> <transformer implementation= "org.apache.maven.plugins.shade.resource.ManifestResourceTransformer"> <mainClass>com.programming.kotlin.chapter01.ProgramKt</mainClass> </transformer> </transformers> </configuration> </execution> </executions> </plugin>
Podemos executar o comando para rodar o nosso JAR sem ter que nos preocupar com a configuração de classpath, pois o plugin cuidou disso: $ java -jar target/chapter01-1.0-SNAPSHOT.jar
IntelliJ e Kotlin Escrever código usando Vim/nano nem sempre é a primeira opção de todos; trabalhar sem a ajuda de um IDE com seu preenchimento automático de código, intelli-sense, atalhos para adição de arquivos ou refatoração de código pode se provar desafiador quanto mais complexo for o projeto. Há algum tempo, no mundo da JVM, a primeira opção das pessoas quando se trata de seu ambiente de desenvolvimento integrado tem sido o IntelliJ. A ferramenta foi criada pela mesma empresa responsável por Kotlin: a JetBrains. Dada a integração entre ambos, essa seria minha primeira opção de IDE, mas, como veremos na próxima seção, não é a única.
Capítulo 1 ■ Introdução à linguagem Kotlin
33
O IntelliJ tem duas versões: Ultimate e Community (gratuita). Para o código que usaremos neste livro, a versão gratuita será suficiente. Se você ainda não tem o IntelliJ instalado, poderá fazer seu download em https://www.jetbrains.com/idea/download. A partir da versão 15.0, o IntelliJ vem com Kotlin, mas mesmo que você tenha uma versão mais antiga, será possível obter suporte para a linguagem instalando o plugin. Basta acessar Settings|Plugins|Install IntelliJ plugins (Configurações|Plugins|Instalar plugins do IntelliJ) e digitar Kotlin na pesquisa. Usaremos o IDE para criar um projeto Gradle com Kotlin ativado, exatamente como fizemos na seção anterior. Depois de ter iniciado o IntelliJ, você deverá escolher Create new project (Criar novo projeto). Uma janela de diálogo será apresentada, na qual você deverá selecionar Gradle na seção à esquerda; marque a opção Kotlin(Java) que está à direita, como podemos ver na figura:
Selecionando um tipo de projeto.
Você já deve ter a variável de sistema JAVA_HOME configurada para que a ferramenta a utilize automaticamente (veja Project SDK na parte superior da imagem de tela). Se não for esse o caso, selecione o botão New (Novo) e navegue para o local em que está o seu Java JDK. Depois de selecioná-lo você estará pronto para o próximo passo, clicando o botão Next (Próximo) disponível na parte inferior à direita da tela. A próxima janela apresentada solicitará que você forneça o Group Id (Id do grupo) e o Artifact Id (Id do artefato). Vamos usar com.programming.kotlin e chapter01 respectivamente. Depois de preenchidos os campos, você poderá passar para o próximo passo do processo, no qual marcará Use auto-import flag (Usar flag de importação automática), assim como Create directories for empty directory roots automatically (Criar diretórios para raízes de diretório vazias automaticamente).
34
Programando com Kotlin
Vá para o próximo passo, em que você deverá informar se deseja armazenar o projeto em sua máquina. Defina a localização do projeto, expanda More Settings (Mais configurações), digite chapter01 para Module name (Nome do módulo) e pressione o botão Finish (Fim). O IntelliJ prosseguirá criando o projeto e você deverá obter o resultado mostrado na imagem de tela a seguir:
Projeto básico Hello World!.
Na pasta kotlin selecionada, clique o botão direito do mouse e selecione a opção New | Package (Novo | Pacote); digite com.programming.kotlin.chapter01:
Configurando o nome do pacote.
Capítulo 1 ■ Introdução à linguagem Kotlin
35
Na pasta kotlin, você deverá ver uma nova pasta correspondente ao que foi digitado antes. Clique o botão direito do mouse, selecione New | Kotlin File/Class (Novo | Arquivo/classe Kotlin) e digite Program.kt:
Criando o arquivo Program.kt.
Agora estamos prontos para começar a digitar o nosso Hello World!. Utilize o mesmo código que criamos antes no capítulo. Você notará o ícone da marca Kotlin à esquerda do editor de arquivo. Se clicar nela, verá a opção para executar o código; se observar a parte inferior de sua janela do IntelliJ, verá o texto Hello World! sendo exibido:
Programa Hello World!.
Muito bem! Você escreveu seu primeiro programa em Kotlin. Configurar o projeto e o código e executar o programa foi fácil e rápido. Se preferir, você poderá ter um projeto Maven em vez de Gradle. Ao selecionar New | Project (Novo | Projeto), selecione Maven do lado esquerdo, marque Create from archetype (Criar a partir de arquétipo) e selecione org.jetbrains.kotlin:kotlin-archetype-jvm na lista apresentada:
36
Programando com Kotlin
Projeto Maven.
Eclipse e Kotlin Pode haver alguns entre vocês que prefiram o IDE Eclipse ao IntelliJ; não se preocupe, pois você ainda pode desenvolver código Kotlin sem ter que abrir mão desse IDE. A essa altura, suponho que você já tenha a ferramenta instalada. No menu, acesse Help | Eclipse Marketplace (Ajuda | Eclipse Marketplace), procure o plugin para Kotlin e instale-o (estou trabalhando com a distribuição mais recente: Eclipse Neon). Depois de ter instalado o plugin e reiniciado o IDE, você estará pronto para criar seu primeiro projeto Kotlin. No menu, selecione File | New | Project (Arquivo | Novo | Projeto) e verá o diálogo a seguir:
Novo projeto Kotlin.
Capítulo 1 ■ Introdução à linguagem Kotlin
37
Clique o botão Next (Próximo) para passar para o próximo passo e, após ter escolhido o local em que está o código-fonte, clique o botão Finish (Fim). Esse não é um projeto Gradle nem Maven! Você pode escolher um deles, mas, então, terá que modificar manualmente build.gradle or pom.xml, como fizemos nas seções Kotlin e Gradle e Kotlin e Maven neste capítulo. De modo semelhante ao projeto no IntelliJ, clique na pasta src, selecione New package (Novo pacote) e chame-o de com.programming.kotlin.chapter01. Para adicionar nosso Program.kt, você precisará clicar no pacote recém-criado com o botão direito do mouse, selecionar New | Other (Novo | Outro) e, então, Kotlin | Kotlin File (Kotlin | Arquivo Kotlin) na lista. Depois que o arquivo estiver criado, digite as linhas de código simples para exibir o texto no console. Você deverá obter o resultado a seguir em seu IDE Eclipse:
Hello World! no Eclipse.
Agora você está pronto para executar o código. No menu, selecione Run | Run (Execução | Executar). Você deverá ser capaz de disparar a execução e, na aba Console na parte inferior de seu IDE, deverá ver o texto Hello World! sendo exibido.
Misturando Kotlin e Java em um projeto Usar linguagens diferente no mesmo projeto é bem comum; já vi projetos em que uma mistura de arquivos Java e Scala compunha a base de código. Poderíamos fazer o mesmo com Kotlin? Certamente. Vamos trabalhar no projeto que criamos antes: Kotlin com Gradle. Você deverá ver a estrutura de diretórios a seguir em seu IntelliJ (o template-padrão para um projeto Java/Kotlin):
38
Programando com Kotlin
Layout do projeto.
Você pode inserir código Java na pasta java. Acrescente um novo pacote na pasta java com o mesmo nome que está na pasta kotlin: com.programming.kotlin.chapter01. Crie uma New | Java class (Novo | Classe Java) chamada CarManufacturer.java e utilize esse código neste exercício: public class CarManufacturer { private final String name; public CarManufacturer(String name) { this.name = name; } public String getName() { return name; } }
E se você quisesse adicionar uma classe Java na subpasta kotlin? Vamos criar uma classe Student semelhante à anterior e fornecer um nome de campo por questões de simplicidade: public class Student { private final String name; public Student(String name) { this.name = name; } public String getName() { return name; } }
Capítulo 1 ■ Introdução à linguagem Kotlin
39
Na função main, vamos instanciar nossas classes: fun main(args: Array<String>) { println("Hellow World! ") val student = Student("Alexandra Miller") println("Student name:${student.name}") val carManufacturer = CarManufacturer("Mercedes") println("Car manufacturer:${carManufacturer.name}") }
Embora o código compile sem problemas, tentar executá-lo fará uma exceção ser lançada em tempo de execução informando que a classe Student não pôde ser encontrada. Devemos fazer com que o compilador Java procure código na pasta src/main/kotlin. Em seu build.gradle, acrescente a instrução a seguir: sourceSets { main.java.srcDirs += 'src/main/kotlin' }
Agora podemos compilar e executar o programa: $gradle jar $ java -jar build/libs/chapter01-1.0-SNAPSHOT.jar
À medida que seu código Kotlin aumentar, a compilação se tornará mais lenta, pois cada arquivo precisará ser recompilado. Contudo, há uma maneira de agilizar o processo: compilar somente os arquivos alterados entre as construções. O modo mais fácil de permitir isso é criar um arquivo chamado gradle.properties com build. gradle e acrescentar-lhe kotlin.incremental=true. Embora a primeira construção não seja incremental, as próximas serão, e você deverá ver seu tempo de compilação ser bastante reduzido. Provavelmente o Maven continua sendo o sistema de construção mais usado na JVM. Assim, veremos como podemos atingir nosso objetivo de misturar código Kotlin e Java no Maven. Começando pelo IntelliJ, selecione New | Project (Novo | Projeto), escolha Maven como opção e procure kotlin-archetype-jvm na lista de arquétipos. Já discutimos isso, portanto deverá ser muito mais fácil na segunda vez. Agora temos um projeto. Na árvore do projeto, você perceberá que não há nenhuma pasta java para código-fonte criada. Vá em frente e crie src/main/java, seguido da pasta de namespace com.programming.kotlin (será uma subpasta da pasta java). Você verá que clicar na pasta java com o botão direito do mouse não fará a opção para criar um pacote ser
40
Programando com Kotlin
apresentada. O projeto ainda não está configurado para incluir código Java. Antes, porém, o que faz o Maven tratar código Kotlin? Se abrir o arquivo pom.xml e acessar a seção de plugins, você verá o plugin kotlin: <plugin> <groupId>org.jetbrains.kotlin</groupId> <artifactId>kotlin-maven-plugin</artifactId> <version>${kotlin.version}</version> <executions> <execution> <id>compile</id> <phase>compile</phase> <goals> <goal>compile</goal> </goals> </execution> <execution> <id>test-compile</id> <phase>test-compile</phase> <goals> <goal>test-compile</goal> </goals> </execution> </executions> </plugin>
Para adicionar código Java à mistura, devemos definir um novo plugin capaz de compilar o bom e velho código Java: <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.5.1</version> <executions> <execution> <id>default-compile</id> <phase>none</phase> </execution> <execution> <id>default-testCompile</id> <phase>none</phase>
Capítulo 1 ■ Introdução à linguagem Kotlin
41
</execution> <execution> <id>java-compile</id> <phase>compile</phase> <goals> <goal>compile</goal> </goals> </execution> <execution> <id>java-test-compile</id> <phase>test-compile</phase> <goals> <goal>testCompile</goal> </goals> </execution> </executions> </plugin>
O compilador Kotlin deve executar antes do compilador Java para que tudo funcione, portanto precisaremos corrigir o plugin Kotlin para que faça exatamente isso: <plugin> <artifactId>kotlin-maven-plugin</artifactId> <groupId>org.jetbrains.kotlin</groupId> <version>${kotlin.version}</version> <executions> <execution> <id>compile</id> <goals> <goal>compile</goal> </goals> <configuration> <sourceDirs> <sourceDir>${project.basedir}/src/main/kotlin</sourceDir> <sourceDir>${project.basedir}/src/main/java</sourceDir> </sourceDirs> </configuration> </execution> <execution> <id>test-compile</id> <goals>
42
Programando com Kotlin <goal>test-compile</goal> </goals> <configuration> <sourceDirs> <sourceDir>${project.basedir}/src/main/kotlin</sourceDir> <sourceDir>${project.basedir}/src/main/java</sourceDir> </sourceDirs> </configuration> </execution> </executions> </plugin>
A fim de poder gerar o JAR executável para o código que estamos prestes a escrever, precisamos de outro plugin Maven: <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-jar-plugin</artifactId> <version>3.0.2</version> <configuration> <archive> <manifest> <addClasspath>true</addClasspath> <mainClass>com.programming.kotlin.HelloKt</mainClass> </manifest> </archive> </configuration> </plugin>
O código anterior dará a você um JAR contendo apenas o seu código; se quiser executá-lo, será necessário ter as dependências extras no classpath: <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-assembly-plugin</artifactId> <version>2.6</version> <executions> <execution> <id>make-assembly</id> <phase>package</phase> <goals> <goal>single</goal> </goals>
Capítulo 1 ■ Introdução à linguagem Kotlin
43
<configuration> <archive> <manifest> <mainClass>com.programming.kotlin.HelloKt</mainClass> </manifest> </archive> <descriptorRefs> <descriptorRef>jar-with-dependencies</descriptorRef> </descriptorRefs> </configuration> </execution> </executions> </plugin>
Agora estamos prontos para acrescentar as classes do exemplo anterior (as classes CarManufacturer e Student) e alterar a classe main para que contenha o seguinte: val student = Student("Jenny Wood") println("Student:${student.name}") val carManufacturer = CarManufacturer("Honda") println("Car manufacturer:${carManufacturer.name}")
Ainda não terminamos. Embora não haja problemas com a compilação, tentar executar o JAR resultará em um erro de tempo de execução informando que a classe Student não foi encontrada. O compilador Java precisa saber do código Java que está na pasta kotlin. Para isso, usaremos outro plugin: <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>build-helper-maven-plugin</artifactId> <executions> <execution> <phase>generate-sources</phase> <goals><goal>add-source</goal></goals> <configuration> <sources> <source>${project.basedir}/src/main/kotlin</source> </sources> </configuration> </execution> </executions> </plugin>
44
Programando com Kotlin
Finalmente estamos prontos para compilar e executar o código. A execução dos comandos a seguir em um terminal resultará na exibição de três linhas na saída: $ mvn package $ java -jar target/chapter01-maven-mix-1.0-SNAPSHOT-jar-with-dependencies.jar
Resumo Este capítulo mostrou como podemos configurar o ambiente de desenvolvimento com as ferramentas necessárias para construir e executar código em Kotlin. Agora você será capaz de executar os exemplos criados no restante do livro, assim como fazer experimentos com seu próprio código Kotlin. No capítulo 2, exploraremos as construções básicas que você usará no cotidiano na programação com Kotlin.