Tutorial do Maven para Android

O Maven é uma ferramenta de gerenciamento de projetos, com ela você pode gerenciar as dependências de seu projeto, automatizar relatórios, execução de testes e etc.

É muito popular em Java mas há também um plugin para usá-lo para gerenciar também um projeto Android.

Pré-requisitos

1. JDK 1.6 +
2. Android SDK
3. Maven 3.0.3 +
4. Eclipse Indigo ou Juno

Primeiramente é necessários configurar a variável de ambiente ANDROID_HOME apontado para o diretório em que está o seu Android SDK, no meu é a seguinte:

export ANDROID_HOME=$HOME/dev/android-sdk

Adicione essa variável em seu path bem como os sub-diretórios $ANDROID_HOME/platform-tools $ANDROID_HOME/tools, exemplo:

export PATH=$PATH:$ANDROID_HOME/platform-tools:$ANDROID_HOME/tools

Para o Windows seria algo como 

%ANDROID_HOME%\tools e %ANDROID_HOME%\platform-tools

Integração com o Eclipse

Para o Maven para android funcionar bem com o eclipse é necessária a instalação do plugin M2E-Android.

Abra o eclipse e no menu superior escolha Help > Eclipse Marketplace.
Busque por Android M2E.
Clique em Install no item Android Configurator for M2E.
Next, next next e finish...
Reinicie o Eclipse.
Pronto seu plugin já deve estar instalado

Criando um projeto com o Maven

É possível criar um projeto Android pelo maven usando o Eclipse, eu pessoalmente prefiro criar na linha de comando.

mvn archetype:generate \
  -DarchetypeArtifactId=android-release \
  -DarchetypeGroupId=de.akquinet.android.archetypes \
  -DarchetypeVersion=1.0.8 \
  -DgroupId=com.blogspot.runnerdtalks\
  -DartifactId=MavenTest \
  -Dplatform=10 \
  -Dpackage=com.blogspot.runnerdtalks.maventest

Esse archetype gerará um projeto com algumas configurações extras para permitir que o app seja publicado no Google Play.

Ao usar esse archetype serão criados 2 projetos, um chamado MavenTeste para o aplicativo e outro chamado MavenTest-it para os testes do aplicativo criado.
Esse archetype já possui configurações que possibilitam a publicação do aplicativo também no Google Play, ainda existem outros archetypes com menos opções pré configuradas, é possível encontrar esses outros archetypes neste link aqui

Importando o Projeto para dentro do Eclipse.

No eclipse vá em File > Import > Existing Maven Projects escolha o diretório do projeto recém criado e selecione só os dois projetos filhos.

E Finish

Se o projeto estiver reclamando da falta dos diretórios src/test/java crie eles e de um refresh no projeto pelo eclipse.

Para adicionar dependências é só editar seu pom.xml como um projeto Maven normal, depois clique com o botão direito em seu projeto vá em Maven > Update Project.

Lembrando que se um dia precisar compartilhar este projeto com seus amigos ou subir no repositório, sempre remover os arquivos do eclipse e os binários de seu SCM.

Referências

Maven Android Plugin
M2E Android
Android Maven Archetypes

Mocks com Mockito - parte 2

Para continuar nosso "papo" sobre Mocks vou apresentar mais algumas funções do Mockito

Como talvez você já tenha percebido o mockito não serve só para mocks, mas serve também para testar o comportamento da classe que está sob teste com suas dependências.

Usando o mesmo exemplo da nossa classe que envia mensagens. Imagine agora que temos um novo métod que recebe uma ou várias mensagens e as envia usando o objeto connection.

Usando o Mockito podemos escrever um teste como o abaixo.

import static org.mockito.Mockito.*;
//class declaration bla bla bla.
@Test
public void behaviourTest() {
  Connection connection = mock(Connection.class);
  
  MyMessageSender messageSender = new MyMessageSender(connection);
  
  messageSender.sendMultipleMessages("Mensagem 1", "Mensagem 2");
  
  verify(connection, times(2)).sendMessage(anyString());
}

Traduzindo a Linha 11:

• Verificar que o método sendMessage com o argumento...
• uma string qualquer
• foi chamada duas vezes

O Mockito também possibilita simular o retorno de mensagens.

Para demonstrar isto criaremos um novo para sabe se a nossa classe está recebendo as mensagens corretamente, nesse caso ao invés de usar o mock para testar a passagem de parâmetros para ele teremos que usa-lo para simular os retornos de seus métodos.

Testaremos a classe MyMessageReader que se parece com a seguinte classe.

public class MyMessageReader {
  private Connection connection;
  
  public MyMessageReader(Connection connection) {
    this.connection = connection;
  }

  public String readMessage() { 
   return connection.readMessage();
  }
}

Novamente nossa classe sob teste usa um objeto Connection, mas desta vez o método que chamamos é connection.readMessage()

Nosso teste então terá que simular um retorno de connection.readMessage(), usando o Mockito ficaria como o código abaixo.

@Test
public void readMessageTest() {
  connection = mock(Connection.class);
  
  given(connection.readMessage()).willReturn("minhaMensagem");
  myMessageReader = new MyMessageReader(connection);
  
  String readedMessage = myMessageReader.readMessage();
  
  assertEquals(readedMessage, "minhaMensagem");
}

Claro que como tudo em programação existe mais de uma maneira simular os retornos de chamados dos métodos, as duas linhas seguintes são equivalentes.

given(connection.readMessage()).willReturn("minhaMensagem");
when(connection.readMessage()).thenReturn("minhaMensagem");

A primeira linha tem uma abordagem mais em linha com BDD, tanto que o método given é da classe BDDMockito.

Caso o método que simulamos o retorno receba um parâmetro podemos definir diferentes tipos de retorno para diferentes parâmetros, como no exemplo abaixo.

Map map = mock(Map.class);
given(map.get(anyString())).willReturn(null);
given(map.get("chave1")).willReturn("valor1");

map.get("chave1"); //retorna string "valor1"
map.get("outraChave");//retorna nulo

No próximo post de Mocks mostrarei como usar Spies em seus testes com Mock.

Se quiser o código completo pode pegar no git hub.
https://github.com/diegoy/talks-mockito

Valeu!

Mais:
Mocks com Mockito, parte 3

Mocks com Mockito

Desta vez vamos ter uma breve introdução ao uso de Mocks em seus testes.

Há vários benefícios que o uso de testes unitários podem trazer, eu pessoalmente gosto muito de ter testes pois ajuda muito na hora de refatorar seu código e ter a certeza de que o seu funcionamento não mudou, escrever os testes também nos ajuda a identificar casos em que o código está com um alto acoplamento.

Usando TDD ou não os testes são importantes mas podem ser muito difícil de escreve-los

Muitas vezes ao tentar escrever testes para algumas classes temos alguns desafios.
Um Software geralmente depende de vários outros sistemas para funcionar, por exemplo uma base de dados, levando isso em conta os testes de classes que se comunicam com a base de dados são mais difíceis de escrever e o uso de um framework de mocks pode ajudar muito! 

Neste artigo vamos falar do Mockito, que é um framework de mocks criado para a linguagem Java (há versões para outras linguagens). 

A instalação é simples, baixe o jar no site do mockito, coloque-o no seu classpath e pronto! Ou se preferir configure no dependencies de seu maven :)

Suponha que em seu código você tenha uma classe que seja responsável por enviar mensagens através de um socket, aqui vou chama-la de MyMessageSender, sua classe tem como regra enviar mensagens somente com letras maiúsculas.

public class MyMessageSender {
 
  private Connection connection;

  public MyMessageSender(Connection connection) {
    this.connection = connection;
  }

  public void send(String string) {
    connection.sendMessage(string.toUpperCase());
  } 
}

No construtor da classe MyMessageSender passamos como parâmetro um objeto do tipo Connection. Esse objeto possui a conexão do socket e também possui um método sendMessage que escreve uma mensagem no socket.

Para fazer o teste unitário desta classe necessitaríamos instanciar a classe connection para passarmos à classe testada.

 
public class Connection {

  // declaracao dos atributos

  public Connection(String hostAddress, int port) {
    super();
    

    this.hostAddress = hostAddress;
    this.port = port;
  }
 
  public boolean connect() {
    try {
      socket = new Socket(hostAddress, port);
      printStream = getPrintStream(); //abre um output stream
      inputStreamReader = getOutputStream(); //abre um input stream
      return true;
    } catch (UnknownHostException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
  
    return false;
  }
 
  public void sendMessage(String message) {
    printStream.print(message);
    printStream.flush();
  }
}

Vendo a classe Connection perceba que será um pouco trabalhoso instancia-la dentro do teste, pois ela se conecta a um sistema externo, levando isso em conta precisaríamos também criar um mock desse sistema externo para testarmos adequadamente a nossa classe. E consequentemente estaríamos testando muito mais que somente nossa classe MyMessageSender.

Usando o Mockito podemos facilmente criar um mock de Connection para usar em nosso teste sem termos que nos preocupar com as conexões que são necessárias a classe Connection.

@Test
public void sendMessageTest() {
 Connection connection = Mockito.mock(Connection.class);
 
 MyMessageSender messageSender = new MyMessageSender(connection);
 
 messageSender.send("Uma mensagem");
 Mockito.verify(connection).sendmessage("UMA MENSAGEM");
}

Na linha 3 criamos um mock da classe Connection.

Na linha 8 colocamos uma verificamos que o método sendmessage do objeto connection foi chamado passando como parâmetro a string "UMA MENSAGEM". Qualquer string diferente da informada na linha do verify vai causar uma falha no teste.

Assim conseguimos garantir o correto funcionamento da classe MyMessageSender sem precisar ficar criando uma instância real da classe Connection.

No próximo post escreverei como o Mockito pode te ajudar para simular respostas de métodos.

Código fonte disponível no meu github
https://github.com/diegoy/talks-mockito

Mais:
Mocks com Mockito, parte 2
Mocks com Mockito, parte 3

Hibernate para iniciantes

Pessoal, neste post vamos demonstrar os passos necessários para utilizar o Hibernate.

O Hibernate é um framework de ORM (Mapeamento objeto-relacional), basicamente é uma maneira de se mapear as tabelas de uma base de dados em objetos no seu programa.

Neste tutorial eu usei o MySQL como base de dados e o Maven para baixar as dependências do projeto, não entrarei em detalhes da instalação do MySQL, sobre o Maven você pode checar o post anterior caso tenha dúvidas.

Primeiramente abra o seu terminal navegue até o diretório onde deseja criar seu projeto e digite o seguinte.

mvn archetype:generate -DgroupId=com.blogspot.runnerdtalks.hibernatetutorial -DartifactId=HibernateTutorial -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Isso irá criar o esqueleto de um projeto Java, dentro do seu diretório HibernateTutorial que foi criado no comando acima você encontrará o seguinte

Agora abra o arquivo pom.xml e vamos adicionar as dependências do hibernate como no trecho abaixo.

<dependencies>
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.16</version>
</dependency>

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.4.2</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.18</version>
</dependency>

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>3.3.0.SP1</version>
</dependency>

<dependency>
    <groupId>org.hibernate</groupId>
   <artifactId>hibernate-annotations</artifactId>
    <version>3.4.0.GA</version>
    </dependency>

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-entitymanager</artifactId>
    <version>3.4.0.GA</version>
</dependency>
</dependencies>

Volte ao seu terminal de digita o seguinte:

mvn install

mvn eclipse:eclipse

O primeiro comando irá baixar as dependências e o segundo irá criar os arquivos necessários para transforma-lo em um projeto eclipse.

Abra seu Eclipse e vá em File>Import>Existing Projects into Workspace e de Next.
Clique em Browse e navegue até o diretório onde você mandou o Maven criar o seu projeto, e finalize a importação.

Se esta é a primeira vez que você usa o Maven para criar um projeto no Eclipse será necessário resolver alguns problemas no seu Build Path. 

Clique com o botão direito no projeto, e escolha Properties, escolha Java Build Path>Libraries>Add Variable>Configure Variables... > New...

Em Name coloque M2_REPO

Em Path deve ser o caminho do diretório onde o Maven baixa as dependências, isso varia dependendo do sistema operacional que você usa mas, em sistemas como o Linux e OSX é ~/.m2/repository para Windows fica em C:\Document and Settings\username\.m2 (pode variar dependendo da versão do Windows)

Dê ok em todos os diálogos que estavam abertos, caso seu projeto ainda de erros de compilação vá em Projects>Clean... para forçar a recompilação

No diretório src/res o arquivo hibernate.cfg.xml, esse xml é o responsável por configurar para o hibernate o caminho do banco de dados, usuário senha e etc.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
  "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
 <session-factory>

  <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
  <property name="hibernate.connection.password">tutorial</property>
  <property name="hibernate.connection.username">username</property>
  <property name="hibernate.connection.url">jdbc:mysql://localhost/hibernateTutorial</property>
  <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

  <property name="hibernate.show_sql">true</property>
  <property name="hibernate.format_sql">true</property>
  <property name="hbm2ddl.auto">create</property>

  <mapping class="com.blogspot.runnerdtalks.hibernatetutorial.entity.User"/>
 </session-factory>
</hibernate-configuration>

Veja que já estamos com uma Entity mapeada, no caso a entity User, deixei ela aí já para nos poupar um passo mas é importante lembrar da necessidade de colocar esse mapeamento no XML.
Lembre-se de fazer as devidas alterações nos campos de conexão, como usuário e senha.

Crie também o arquivo log4j.properties no mesmo diretório como abaixo.

log4j.logger.org.hibernate = info, CONSOLE
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n

Será necessário colocar os arquivos no seu classpath, clique com o botão direito em seu projeto vá em Properties>Java Build Path>Source>Add Folder... adicione o diretório res e clique em ok.

Agora vamos criar a nossa entity User, como já definimos ela no Hibernate.cfg.xml é importante cria-lá no mesmo pacote: com.blogspot.runnerdtalks.hibernatetutorial.entity


Sua entity vai ficar como a seguinte

package com.blogspot.runnerdtalks.hibernatetutorial.entity;

//imports

@Entity
public class User {

 @Id
 @GeneratedValue
 private Long id; 

 private String name;

 private String password;

 //adicione aqui seus getters e setters

}

Veja que a classe esta anotada com @Entity que identifica que essa é uma Entity do Hibernate, e que temos um membro da classse anotado com @Id e @GeneratedValue

• @ID identifica que ela é a chave primária de sua tabela
• @GeneratedValue é para o próprio hibernate atribuir os valores para ela automaticamente.

Os outros membros não possuem anotação, mas mesmo assim eles serão automagicamente mapeados para colunas na tabela.

Para sua entity isto é o suficiente

Perceba que temos nossa entity mapeada para uma base de dados que não tem nada criado! É porque agora vamos fazer o Hibernate gerar as tabelas da base de dados baseado em nossa entity.

Conecte no mysql com o comando

mysql -u user -p

Dentro do console do mysql vamos criar a base de dados.

create database hibernateTutorial;

Selecione a base de dados recém criada.

use hibernateTutorial

E execute o seguinte para mostrar as tabelas

show tables;

Seu resultado será algo como o seguinte

Crie uma nova classe no pacote com.blogspot.runnerdtalks.hibernatetutorial.main chamada GenerateSchema.

public class GenerateSchema {

    public static void main( String[] args ) {

     //Le o hibernate.cfg.xml

     AnnotationConfiguration annotationConfiguration = new AnnotationConfiguration();
     annotationConfiguration.configure();

     SchemaExport se = new SchemaExport(annotationConfiguration);
     se.create(true, true);
    }
}

E execute...

O console do eclipse irá mostrar para você diversos detalhes do hibernate se conectando a base de dados e também aparecerá um comando SQL.

Volte ao terminal que você está conectado ao MySQL e execute novamente

show tables;

O resultado deverá mostrar agora a table User, uma tabela não é nada sem dados correto? Então vamos criar uma nova classe chamada CreateNewUser no mesmo pacote do GenerateSchema.

public class CreateNewUser {

 public static void main(String[] args) {

  AnnotationConfiguration annotationConfiguration = new AnnotationConfiguration();
  annotationConfiguration.configure();

  SessionFactory sessionFactory = annotationConfiguration
    .buildSessionFactory();
  Session session = sessionFactory.openSession();

  User user = new User();
  user.setName("root");
  user.setPassword("raquel");

  Transaction transaction = session.beginTransaction();
  session.save(user);
  transaction.commit();
 }
}

Volte ao MySQL e execute

select * from User;

Seu terminal irá exibir o recém criado usuário na tabela.

Caso tenha percebido que sua tabela esteja sendo recriado toda vez que executa o código é por culpa dessa linha no xml.

<property name="hbm2ddl.auto">create</property>

Comente-a e a execução do código não fará mais sua tabela ser recriada.

Código Fonte no GitHub

Valeu!

Maven

No Util.runNerdTalks(5) falamos sobre Maven.



O Maven, é uma ferramenta para gerenciamento e automação de projetos em Java. Ele é todo baseado em XML, e muito similar ao Ant.





Download

Para fazer o download entre na página oficial, ou baixe via apt-get.



Após instalar verifique via linha de comando se está funcionando:

mvn --version

Aparecerá algo parecido como:







Exemplo Básico

O arquivo básico de configuração é o pom.xml. O pom vem de Project Object Model (POM).



Exemplo básico:

<project>
<modelVersion>4.0.0</modelVersion>
<groupId>com.runnerdtalks</groupId>
<artifactId>teste</artifactId>
<version>1.0</version>
</project>

Sendo que:
- modelVersion, é a identificação da versão do arquivo pom.xml (padrão 4.0.0)
- groupId - identificador da empresa / site
- artifactId - nome do projeto
- version - versão do projeto



Criando um projeto novo

Você não precisa digitar todo o xml caso esteja iniciando um projeto novo.



Você pode digitar por exemplo:

mvn archetype:create -DgroupId=com.runnerdtalks -DartifactId=teste -DarchetypeArtifactId=maven-archetype-webapp

Ele construirá um projeto tipo webapp



Ou ainda:

mvn archetype:generate

Assim você escolherá passo a passo as variáveis do projeto.





Adicionando dependências

Para adicionar uma dependência (um jar como o do jUnit por exemplo) a esse projeto, adiciona-se a seguinte estrutura:

<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>

Nesse exemplo, adicionamos o jUnit versão 3.8.1.



O Maven baixará automaticamente do seu repositório, o http://mvnrepository.com/ para sua máquina local, colocando-o no diretório .m2/repository (No Unix/Mac OS X pode-se encontrar no ~/.m2 e no Windows – C:\Documents and Settings\username\.m2 )



O .m2/repository é um repositório local, onde será armazenado todos os seus downloads. Assim se você tiver outro projeto que utilizará por exemplo o jUnit 3.8.1, o Maven não precisará baixá-lo novamente.



Mais um exemplo. imagine que você queira usar o hibernate-annotations versão 3.5.6-final. Adicionaremos em nosso pom.xml:

<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-annotations</artifactId>
<version>3.5.6-Final</version>
</dependency>

Mas nesse caso o hibernate-annotations também tem suas dependências, como:

org.hibernate.hibernate-core

org.hibernate.hibernate-commons-annotations

org.hibernate.javax.persistence.hibernate-jpa-2.0-api

Assim, além do próprio hibernate-annotations, ele baixará outros jars.



Principais comandos

A partir do pom.xml (que estará na raiz do seu projeto) você digita na linha de comando:

mvn clean - apaga o diretório target, e os .class

mvn compile - compila seu projeto

mvn test - roda os testes unitáros do projeto

mvn install - instala seu projeto (jar/war/etc) no repositório local

mvn deploy - envia o projeto (jar/war/etc) para um servidor remoto

Plugins

O Maven também possui vários plugins (veja mais aqui).

Um exemplo é o plugin para transformar seu projeto em um projeto Eclipse (gerando o .project)

Outros comandos

Alguns comandos interessantes:

mvn dependency:tree - Mostra a dependencia de todos os jars existentes do seu projeto

mvn eclipse:eclipse - Gera o projeto no eclipse

Projeto no Eclipse

Como o Maven já construiu o seu projeto para o Eclipse (após rodar o mvn eclipse:eclipse), você pode simplesmente importar o projeto:

Após isso não esqueça de entrar no "properties" do projeto e configurar a variável M2_REPO
Properties-->Java Build Path -->Add Variable..-->Configure Variables...-->New
Name: M2_REPO
Path: Local do ./m2/repository (No Unix/Mac OS X pode-se encontrar no ~/.m2 e no Windows – C:\Documents and Settings\username\.m2 )


Exemplo
https://github.com/AleUehara/sample-maven

Fonte

Maven - http://maven.apache.org/

Blog da Caelum - http://blog.caelum.com.br/processo-de-build-com-o-maven/

Java

Olá! Seja bem vindo ao Utils.runNerdTalks();!

Esse post de abertura é praticamente um Hello World, pelo menos até acostumarmos com as ferramentas do Blogger... aliás, podemos ser iniciantes ou com vários anos de experiência em programação, mas sempre voltamos a escrever programas do tipo Hello World, cada vez de uma forma diferente, utilizando novas técnicas ou linguagens... e sempre é uma alegria quando aquela porcaria funciona, por mais simples que seja o projeto! Significa um passo adiante em nosso aprendizado e abre caminhos para novas soluções... ou no mínimo permite uma linha a mais em nosso currículo!

E esse é o cenário desse blog, pretendemos conversar e discutir sobre nossas experiências e dificuldades em diversas tecnologias, e sempre que possível, acompanhado de códigos simples dentro do contexto abordado pelo post.

Para esse post, montamos o mais simples Hello World de uma das linguagens mais populares atualmente, o Java.

Ambiente de Desenvolvimento - Java

1. Faça download do Java SE Development Kit (JDK):
   
   
   
2. Execute a instalação padrão:
   
   
   
3. No Windows, clique no menu "Iniciar" / "Painel de Controle" / "Sistema" / "Avançado" / "Variáveis de Ambiente" para criar ou editar as variáveis de ambiente:
   • JAVA_HOME = aponte para o diretório onde foi instalado o JDK
   • PATH = inclua o caminho %JAVA_HOME%\bin
   • CLASSPATH = inclua o caminho . na variável de ambiente

Projeto Hello World

1. Crie um arquivo no Bloco de Notas chamado HelloWorld.java:
   
   

   public class HelloWorld {
   
    public static void main(String[] args) {
     System.out.println("Hello World");
   
    }
   
   }
   

   
   
2. O programa será compilado através da linha de comando javac HelloWorld.java, e para execução, basta digitar java HelloWorld:
   
   
   

Ambiente de Desenvolvimento - Eclipse

Embora o exemplo seja a base para o desenvolvimento em Java, a grande maioria dos projetos são desenvolvidos através de uma IDE, programa que auxilia na edição, compilação, depuração e execução dos códigos-fontes. E uma das IDEs mais utilizadas no mercado é o Eclipse.

1. Faça download do Eclipse:
   
   
   
2. Descompacte o arquivo em algum local, por exemplo C:\, execute eclipse.exe e selecione um diretório para seu workspace, ou seja, local onde serão gravados seus arquivos de configuração do Eclipse e projetos:
   
   
   
3. Seu ambiente está pronto:
   
   
   

Projeto Hello World - Eclipse

1. Crie um novo projeto Java através da tecla de atalho Ctrl+N:
   
   
   
2. Dê um nome para o projeto:
   
    
3. Crie uma nova classe através da tecla de atalho Ctrl+N:
   
   
   
   
4. Dê um nome para a classe, por exemplo HelloWorld:
   
   
   
5. Preencha o conteúdo da classe HelloWorld com o código realizado no exemplo anterior:
   
   
   
6. Execute o código através da tecla de atalho Ctrl + F11 e veja o resultado na aba Console: