Desenvolvendo Aplicações Java Gerais

O tutorial resumido a seguir orienta você por algumas etapas básicas do desenvolvimento de uma aplicação Java SE no NetBeans IDE. Este tutorial pressupõe que você já tenha alguma familiaridade com o desenvolvimento de aplicações Java. Ao longo do caminho, será possível ver algumas das funcionalidades do IDE que simplificam o desenvolvimento de aplicações.

Será criado uma aplicação que converte várias palavras em uma única palavra que contém uma letra de cada uma das outras palavras. A palavra resultante é chamada de acróstico.

Este tutorial demora aproximadamente 30 minutos para ser concluído. Se quiser um tutorial "Hello World" mais rápido, consulte o Tutorial para Início Rápido em Java do NetBeans IDE.

Conteúdo

O conteúdo desta página se aplica ao NetBeans IDE 6.9 e versão mais recente

Para concluir este tutorial, são necessários o software e os recursos apresentados na tabela a seguir.

Software ou Recurso Versão Necessária
NetBeans IDE versão 6.9 ou posterior
Java Development Kit (JDK) versão 6 ou versão 7

Configuração do Projeto

A aplicação criada conterá dois projetos:

  • Um projeto da Biblioteca de Classe Java no qual você criará uma classe do utilitário.
  • Um projeto da Aplicação Java com uma classe principal que implementa um método da classe do utilitário do projeto da biblioteca.

Depois de criar os projetos, você adicionará o projeto da biblioteca ao classpath do projeto da aplicação. Em seguida, você codificará a aplicação. O projeto da biblioteca conterá uma classe de utilitário com um método de acróstico. O método acróstico utiliza um array de palavras como um parâmetro e, em seguida, gera um acróstico com base nessas palavras. O projeto MyApp conterá uma classe principal que chama o método acróstico e passa as palavras que são inseridas como argumentos quando a aplicação é executada.

Observação: falando estritamente, dois projetos não são necessários para uma aplicação tão simples. Este tutorial utiliza dois projetos para demonstrar as funcionalidades que você pode precisar para uma aplicação mais complexa.

Criando um Projeto de Biblioteca de Classe Java

  1. Selecione Arquivo > Novo Projeto (Ctrl-Shift-N). Em Categorias, selecione Java. Em Projetos, selecione Biblioteca de Classe Java. Clique em Próximo.
  2. Em Nome do Projeto, digite MyLib. Altere a Localização do Projeto em qualquer diretório de seu computador. De agora em diante, este tutorial se refere a esse diretório como NetBeansProjects.

    Observação: o caminho especificado acima deve estar como a seguir no campo Pasta do Projeto do assistente: /NetBeansProjects/MyLib/

  3. (Opcional) Marque a caixa de seleção Utilizar Pasta Dedicada para Armazenamento de Bibliotecas e especifique o local da pasta de bibliotecas. Consulte Compartilhando Bibliotecas do Projeto para obter mais informações sobre esta opção.
  4. Clique em Finalizar. O projeto MyLib será exibido nas janelas Projetos e Arquivos.

Criando um Projeto de Aplicação Java

  1. Escolha Arquivo > Novo Projeto. Em Categorias, selecione Java. Em Projetos, selecione Aplicação Java. Clique em Próximo.
  2. Em Nome do Projeto, digite MyApp. Certifique-se de que a Localização do Projeto esteja definida como NetBeansProjects.
  3. (Opcional) Marque a caixa de seleção Utilizar Pasta Dedicada para Armazenar Bibliotecas.
  4. Insira acrostic.Main como classe principal.
  5. Verifique se as caixas de seleção Definir como Projeto Principal e Criar Classe Principal estão marcadas.
  6. Clique em Finalizar. O projeto MyApp é exibido na janela Projeto e Main.java será exibido no Editor de Código-fonte.

Configurando o Classpath de Compilação

Como o MyApp vai depender de uma classe em MyLib, é necessário adicionar a MyLib ao classpath do MyApp. Isso também garante que as classes no projeto MyApp possam se referir a classes no projeto MyLib sem causar erros de compilação. Além disso, isso permite que você utilize a funcionalidade autocompletar código no projeto MyApp para preencher o código com base no projeto MyLib. No IDE, o classpath é visualmente representado pelo nó Bibliotecas.

Para adicionar as classes de utilitário da biblioteca ao classpath do projeto:

  1. na janela Projetos, clique com o botão direito do mouse no nó Bibliotecas do projeto MyApp e selecione Adicionar Projeto, como mostrado na imagem a seguir.

    Imagem mostrando o comando Adicionar Projeto que é oferecida quando você clica com o botão direito em um nó do projeto.

  2. Navegue para NetBeansProjects/ e selecione a pasta de projeto MyLib. O painel Arquivos JAR do projeto mostrará os arquivos JAR que podem ser adicionados ao projeto. Observe que um arquivo JAR do MyLib está listado, embora ainda não tenha sido construído. Esse arquivo JAR será contruído quando você construir e executar o projeto MyApp.
  3. Clique em Adicionar Arquivos JAR do Projeto.
  4. Expanda o nó Bibliotecas. O arquivo JAR do projeto MyLib será adicionado ao classpath do projeto MyApp.

Criando e Editando o Código-fonte Java

Agora é necessário criar um pacote Java e adicionar o método que será utilizado para construir o acróstico. Depois disso, é necessário implementar o método acróstico na classe Principal.

Criando um Pacote e um Arquivo de Classe Java

  1. Clique com o botão direito do mouse no nó do projeto MyLib e selecione Novo > Classe Java. Digite LibClass como nome da nova classe, digite org.me.mylib no campo Pacote e clique em Finalizar. LibClass.java será aberto no Editor de Código-fonte.
  2. Em LibClass.java, coloque o cursor na linha após a declaração de classe (public class LibClass {.
  3. Digite ou cole este código de método:
        public static String acrostic(String[] args) {
            StringBuffer b = new StringBuffer();
            for (int i = 0; i < args.length; i++) {
                if (args[i].length() > i) {
                    b.append(args[i].charAt(i));
                } else {
                    b.append('?');
                }
            }
            return b.toString();
                    }
  4. Se o código colado não estiver formatado corretamente, pressione Alt-Shift-F para reformatar todo o arquivo.
  5. Pressione Ctrl-S para salvar o arquivo.

Editando um Arquivo Java

Agora, você adicionará algum código em Main.java. Ao fazê-lo, você pode ver as funcionalidades autocompletar código do Editor de Código-fonte e o modelo (abreviação) de código.

  1. Selecione a guia Main.java no Editor de Código-fonte. Expanda o acróstico MyApp > Pacotes de Código-fonte > na janela Projetos e clique duas vezes em Main.java, se ele ainda não estiver aberto.
  2. Delete o comentário // lógica da aplicação do código TODO aqui no método main.
  3. No lugar do comentário, digite o seguinte:
    String result = Li

    Deixe o cursor imediatamente depois de Li. Na próxima etapa, você utilizará a funcionalidade autocompletar código para transformar Li em LibClass.

  4. Pressione Ctrl-Espaço para abrir a caixa para autocompletar código.

    Aparece uma lista resumida de formas possíveis para completar a palavra. Contudo, a classe que você deseja, LibClass, pode não existir.

  5. Pressione Ctrl-Espaço novamente para exibir uma lista mais longa de possíveis correspondências.

    LibClass deve estar na lista.

  6. Selecione LibClass e pressione Enter. O IDE preencherá o resto do nome da classe, além de criar automaticamente uma instrução de importação para a classe.

    Observação: o IDE também abrirá uma caixa acima da caixa para autocompletar código que exibe informações de Javadoc da classe ou do pacote selecionado. Como não há informações Javadoc para esse pacote, a caixa exibe a mensagem "Não é possível localizar o Javadoc".

  7. No método principal, digite um ponto (.) depois de LibClass. A caixa para autocompletar código se abrirá novamente.
  8. Selecione o método acrostic(String[]args) e pressione Enter. O IDE preenche o método acróstico e mostra os realces do parâmetro args.
  9. Pressione Enter para aceitar args como o parâmetro.
  10. Insira um ponto-e-vírgula (;).

    A linha final deve se parecer com a linha a seguir.

    String result = LibClass.acrostic(args);
  11. Pressione Enter para iniciar uma nova linha. Depois, digite sout e pressione Tab. A abreviação sout se expandirá para System.out.println(""); com o cursor posicionado entre as aspas. Digite Result = dentro das aspas e + result após as aspas finais.

    A linha final deve se parecer com a linha a seguir.

    System.out.println("Result = " + result);
  12. Pressione Ctrl-S para salvar o arquivo.

Observação: sout é um dos vários modelos de código disponíveis no Editor de Código-fonte. Para encontrar e editar a lista de modelos de código, escolha Ferramentas > Opções > Editor > Modelo de Código.

Compilando e Executando a Aplicação

Agora é necessário definir a classe principal e os argumentos de execução para que possa executar o projeto.

Observação: por default, os projetos foram criados com a funcionalidade Compilar ao Salvar ativada, assim, não é necessário compilar seu código antes de executar a aplicação no IDE. Para obter mais informações sobre a funcionalidade Compilar ao Salvar, consulte a seção Compilar ao Salvar no guia Criando, Importando e Configurando Projetos Java.

Definindo a Classe Principal e os Argumentos de Execução

A saída deste programa tem base nos argumentos fornecidos quando o programa é executado. Como argumentos, você fornecerá cinco palavras, das quais o acróstico "Hello" será gerado. O acróstico é montado a partir da primeira letra da primeira palavra, da segunda letra da segunda palavra, da terceira letra da terceira palavra, e assim por diante.

Para adicionar os argumentos que o IDE utilizará ao executar a aplicação:

  1. clique com o botão direito do mouse no nó do projeto MyApp, selecione Propriedades e o nó Executar no painel esquerdo da caixa de diálogo.

    A classe principal já deve estar definida para acrostic.Main.

  2. Digite However we all feel zealous no campo Argumentos e clique em OK.

Executando a Aplicação

Agora que você criou a aplicação e forneceu os argumentos de runtime para a aplicação, pode testar a execução da aplicação no IDE.

Para executar a aplicação no IDE:

  • Escolha Executar > Executar Projeto Principal (F6).

    Na janela de Saída, é possível ver a saída do programa, Result = Hello (o acróstico da frase que foi passada para o programa como um argumento).

Testando e Depurando a Aplicação

Agora um teste do projeto será criado e executado utilizando JUnit e, em seguida, a aplicação será executada no depurador do IDE para verificar se há erros. No teste JUnit, a LibClass será testada com a passagem de uma frase para o método acróstico e com a utilização de uma asserção para indicar qual deve ser o resultado.

Criando Testes JUnit

  1. Clique com o botão direito do mouse no nó LibClass.java na janela Projetos e selecione Ferramentas > Criar Testes JUnit (Ctrl-Shift-U).

    Se esta é a primeira vez que criou testes JUnit no IDE, você verá a caixa de diálogo Selecionar Versão de JUnit. Pressione Enter para selecionar JUnit 4.x e prosseguir para a caixa de diálogo Criar Testes.

  2. Na caixa de diálogo Criar Testes, clique em OK para executar o comando com as opções default. O IDE criará o pacote org.me.mylib e o arquivo LibClassTest.java em uma pasta de teste separada. É possível localizar esse arquivo expandindo o nó Testar Pacotes e o subnó org.me.mylib.
  3. Em LibClassTest.java, delete o corpo do método public void testAcrostic().
  4. No lugar das linhas deletadas, digite ou cole o seguinte:
    System.err.println("Running testAcrostic...");
    String result = LibClass.acrostic(new String[]
                      {"fnord", "polly", "tropism"});
                    assertEquals("Correct value", "foo", result);
  5. Salve o arquivo pressionando Ctrl-S.

Executando Testes JUnit

  1. Selecione o nó do projeto MyLib e selecione Executar > Testar Projeto (MyLib) ou pressione Alt-F6. A guia MyLib (teste) será exibida na janela Saída. Os casos de teste JUnit serão compilados e executados. O resultado do teste JUnit mostra que o teste teve êxito.
  2. Também é possível executar um único arquivo no teste em vez de testar todo o projeto. Selecione a guia LibClass.java no Editor de Código-fonte e escolha Executar > Testar Arquivo.

A documentação da API JUnit está disponível no IDE. Escolha Ajuda > Referências de Javadoc > JUnit VersionNumber.

Você pode aprender mais sobre JUnit, visitando http://www.junit.org

Depurando a Aplicação

Nesta seção, o depurador será utilizado para seguir a sequência da aplicação e observar os valores das variáveis mudarem à medida que o acróstico é montado.

Para executar a aplicação no depurador:

  1. No arquivo LibClass.java, vá para o método acrostic e coloque o ponto de inserção em qualquer lugar dentro de b.append(args[i].charAt(i));. Depois, pressione Ctrl-F8 para definir um ponto de interrupção.
  2. Selecione Depurar > Depurar Projeto Principal (Ctrl-F5). O IDE abrirá as janelas do Depurador e executará o projeto no depurador, até que o ponto de interrupção seja atingido.
  3. Selecione a janela Variáveis Locais, na parte inferior do IDE e expanda o nó args. O array de strings contém a frase inserida como argumentos do comando.
  4. Pressione F7 (ou selecione Depurar > Fazer Step Into) para passar pelo programa e observar a variável b mudar à medida que o acróstico é construído.

    Quando o programa chegar ao fim, as janelas do depurador serão fechadas.

Para obter mais informações, veja Escrevendo Testes JUnit no NetBeans IDE.

Construindo, Executando e Distribuindo a Aplicação

Quando estiver satisfeito com o funcionamento de sua aplicação, você pode preparar a aplicação para implantação fora do IDE. Nesta seção, o arquivo JAR da aplicação será construído e, em seguida, o arquivo JAR executado a partir da linha de comandos.

Construindo a Aplicação

O comando construir principal no IDE é o comando Limpar e Construir. O comando Limpar e Construir deleta as classes compiladas anteriormente e outros artefatos de construção e, em seguida, reconstrói todo o projeto.

Observações: há também um comando Construir, que não deleta os antigos artefatos de construção, mas que está desativado por default. Consulte a seção Compilar ao Salvar no guia Criando, Importando e Configurando Projetos Java para obter mais informações.

Para construir a aplicação:

  • Escolha Executar > Limpar e Construir Projeto Principal (Shift-F11).

A saída obtida a partir do script de construção Ant é exibida na janela Saída. Se a janela Saída não aparecer, é possível abrí-la manualmente selecionando Janela > Saída > Saída.

Quando você limpa e constrói seu projeto, ocorre o seguinte:

  • As pastas de saída geradas por ações de construção anteriores são deletadas ("limpas"). (Na maioria dos casos, essas são as pastas build e dist.)
  • As pastas build e dist são adicionadas em sua pasta do projeto (de agora em diante chamada pasta PROJECT_HOME). Você pode exibir essas pastas na janela Arquivos.
  • Todos os códigos-fonte são compilados em arquivos .class, que são colocados na pasta PROJECT_HOME/build.
  • Um arquivo JAR contendo o projeto é criado dentro da pasta PROJECT_HOME/dist.
  • Se alguma biblioteca foi especificada para o projeto (além do JDK), uma pasta lib é criada na pasta dist. As bibliotecas são copiadas para dist/lib.
  • O arquivo de manifesto no JAR é atualizado para incluir entradas que designam a classe principal e quaisquer bibliotecas que estejam no classpath do projeto.

Observação: é possível exibir o conteúdo do manifesto na janela Arquivos do IDE. Depois de construir seu projeto, alterne para a janela Arquivos e navegue até dist/MyApp.jar. Expanda o nó do arquivo JAR, expanda a pasta META-INF e clique duas vezes em MANIFEST.MF para exibir o manifesto no Editor de Código-fonte.

Main-Class: acrostic.Main
            Class-Path: lib/MyLib.jar

(Para saber mais sobre arquivos de manifesto, leia este capítulo no Tutorial de Java.)

Executando a Aplicação fora do IDE

Para executar a aplicação fora do IDE:

  1. em seu sistema, abra um prompt de comando ou uma janela de terminal.
  2. No prompt de comando, altere os diretórios para o diretório MyApp/dist.
  3. Na linha de comandos, digite a seguinte instrução:
                    java -jar MyApp.jar However we all feel zealous    

Em seguida, a aplicação executa e retorna a saída a seguir, como mostrado na imagem abaixo:

Result = Hello
            
Prompt de comando mostrando a saída do programa em execução.

Distribuindo a Aplicação para Outros Usuários

Agora que verificou que a aplicação funciona fora do IDE, você está pronto para distribuir a aplicação.

Para distribuir a aplicação:

  1. em seu sistema, crie um arquivo zip que contenha o arquivo JAR da aplicação (MyApp.jar) e a pasta lib correspondente que contém o MyLib.jar.
  2. Envie o arquivo para as pessoas que utilizarão a aplicação. Oriente-as a descompactar o arquivo zip, certificando-se de que o arquivo MyApp.jar e a pasta lib estejam na mesma pasta.
  3. Oriente os usuários a seguir as etapas na seção Executando a Aplicação Fora do IDE acima.

Outras Tarefas Comuns

Agora a parte principal do tutorial foi concluída, mas há algumas tarefas básicas que ainda não foram abordadas. Esta seção inclui algumas dessas tarefas.

Tornando o Javadoc Disponível no IDE

Para exibir a documentação da API JavaSE no NetBeans IDE, utilize o comando Código-fonte > Exibir Documentação ou escolha Janela > Outro > Javadoc no menu principal para exibir a documentação da API em outra janela.

No entanto, em algumas bibliotecas de terceiros, a documentação da API não está disponível. Nesses casos, os recursos do Javadoc devem ser associados manualmente ao IDE.

Para tornar a documentação da API Javadoc disponível para o comando Mostrar Javadoc:

  1. Faça download do código-fonte da documentação da API Javadoc.
  2. Escolha Ferramentas > Bibliotecas.
  3. Na lista Bibliotecas, selecione a biblioteca que seu projeto está utilizando.
  4. Clique na guia Javadoc.
  5. Clique no botão Adicionar ZIP/Pasta e navegue até o arquivo zip ou à pasta que contém a documentação da API Javadoc em seu sistema. Selecione o arquivo zip ou a pasta e clique no botão Adicionar ZIP/Pasta.
  6. Clique em Fechar.

Gerando o Javadoc de um Projeto

É possível gerar a documentação compilada do Javadoc de seu projeto com base nos comentários do Javadoc que foi adicionado em suas classes.

Para gerar documentação do Javadoc para um projeto:

  1. Selecione o Projeto MyLib.
  2. No menu principal do IDE, selecione Executar > Gerar Javadoc para "MyLib".
    O Javadoc gerado é adicionado à pasta dist do projeto. Além disso, o IDE abre uma janela do Web browser que exibe o Javadoc.

Próximas Etapas

Para obter mais informações sobre o uso do NetBeans IDE para desenvolver aplicações Java SE, consulte os seguintes recursos:

get support for the NetBeans

Support


By use of this website, you agree to the NetBeans Policies and Terms of Use. © 2013, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo