Desenvolvendo Aplicações Java Gerais
This tutorial needs a review. You can open a JIRA issue, or edit it in GitHub following these contribution guidelines. |
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.

Para concluir este tutorial, você precisa do software e dos recursos apresentados na tabela a seguir.
Software ou Recurso | Versão Necessária |
---|---|
7.4 ou 8.0 |
|
6, 7 ou 8 |
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]]
-
Selecione Arquivo > Novo Projeto (Ctrl-Shift-N). Em Categorias, selecione Java. Em Projetos, selecione Biblioteca de Classe Java. Clique em Próximo.
-
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 comoNetBeansProjects
.
Observação: o caminho especificado acima deve estar como a seguir no campo Pasta do Projeto do assistente: /
NetBeansProjects
/MyLib/
-
(Opcional) Marque a caixa de seleção Utilizar Pasta Dedicada para Armazenamento de Bibliotecas e especifique o local da pasta de bibliotecas. Consulte Compartilhando uma Biblioteca com Outros Usuários em Desenvolvendo Aplicações com o NetBeans IDE para obter mais informações sobre essa opção.
-
Clique em Finalizar. O projeto MyLib será exibido nas janelas Projetos e Arquivos.
[[Criando um Projeto de Aplicação Java]]
-
Escolha Arquivo > Novo Projeto. Em Categorias, selecione Java. Em Projetos, selecione Aplicação Java. Clique em Próximo.
-
Em Nome do Projeto, digite
MyApp
. Certifique-se de que a Localização do Projeto esteja definida comoNetBeansProjects
. -
(Opcional) Marque a caixa de seleção Utilizar Pasta Dedicada para Armazenar Bibliotecas.
-
Insira
acrostic.Main
como classe principal. -
Certifique-se de que a caixa de seleção Criar Classe Principal esteja marcada.
-
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:
-
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.

-
Navegue para
NetBeansProjects/
e selecione a pasta de projetoMyLib
. 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. -
Clique em Adicionar Arquivos JAR do Projeto.
-
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
-
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, digiteorg.me.mylib
no campo Pacote e clique em Finalizar.LibClass.java
será aberto no Editor de Código-fonte. -
Em
LibClass.java
, coloque o cursor na linha após a declaração de classe (public class LibClass {
. -
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();
}
-
Se o código colado não estiver formatado corretamente, pressione Alt-Shift-F para reformatar todo o arquivo.
-
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.
-
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 emMain.java
, se ele ainda não estiver aberto. -
Delete o comentário
// lógica da aplicação do código TODO aqui
no métodomain
. -
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
.
-
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.
-
Pressione Ctrl-Espaço novamente para exibir uma lista mais longa de possíveis correspondências.
LibClass
deve estar na lista.
-
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".
-
No método principal, digite um ponto (.) depois de
LibClass
. A caixa para autocompletar código se abrirá novamente. -
Selecione o método
acrostic(String[]args)
e pressione Enter. O IDE preenche o métodoacróstico
e mostra os realces do parâmetroargs
. -
Pressione Enter para aceitar
args
como o parâmetro. -
Insira um ponto-e-vírgula (;).
A linha final deve se parecer com a linha a seguir.
String result = LibClass.acrostic(args);
-
Pressione Enter para iniciar uma nova linha. Depois, digite
sout
e pressione Tab. A abreviaçãosout
se expandirá paraSystem.out.println("");
com o cursor posicionado entre as aspas. DigiteResult =
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);
-
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, consulte Compilando um Único Arquivo Java em Desenvolvendo Aplicações com o NetBeans IDE.
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:
-
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
.
-
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:
-
Clique com o botão direito do mouse no nó do projeto MyApp e escolha Limpar e Construir.
-
Escolha Executar > Executar Projeto (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
-
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.
-
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 arquivoLibClassTest.java
em uma pasta deteste
separada. É possível localizar esse arquivo expandindo o nó Testar Pacotes e o subnóorg.me.mylib
. -
Em
LibClassTest.java
, delete o corpo do métodopublic void testAcrostic()
. -
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);
-
Salve o arquivo pressionando Ctrl-S.
Executando Testes JUnit
-
Selecione o nó do projeto MyLib e selecione Executar > Testar Projeto (MyLib) ou pressione Alt-F6. A guia ` MyLib (teste)` será exibida na janela de Saída. Os casos de teste JUnit serão compilados e executados. O resultado do teste JUnit mostra que o teste teve êxito.
-
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:
-
No arquivo
LibClass.java
, vá para o métodoacrostic
e coloque o ponto de inserção em qualquer lugar dentro deb.append(args[i].charAt(i));
. Depois, pressione Ctrl-F8 para definir um ponto de interrupção. -
Selecione Depurar > Depurar Projeto (Ctrl-F5). O IDE abrirá as janelas do Depurador e executará o projeto no depurador, até que o ponto de interrupção seja atingido.
-
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. -
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 Sobre a Criação de Projetos Java em Desenvolvendo Aplicações com o NetBeans IDE para obter mais informações.
Para construir a aplicação:
-
Escolha Executar > Limpar e Construir Projeto (Shift-F11).
A saída obtida a partir do script de construção Ant é exibida na janela de Saída. Se a janela de 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
edist
.) -
As pastas
build
edist
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 pastaPROJECT_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 pastadist
. As bibliotecas são copiadas paradist/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:
-
em seu sistema, abra um prompt de comando ou uma janela de terminal.
-
No prompt de comando, altere os diretórios para o diretório
MyApp/dist
. -
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
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:
-
em seu sistema, crie um arquivo zip que contenha o arquivo JAR da aplicação (
MyApp.jar
) e a pastalib
correspondente que contém oMyLib.jar
. -
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 pastalib
estejam na mesma pasta. -
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 de API JavaSE no NetBeans IDE, utilize o comando Código-fonte > Mostrar Documentação ou escolha Janela > Ferramentas IDE > Documentação do 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:
-
Faça download do código-fonte da documentação API de Javadoc (consulte a página FaqJavaDoc para obter detalhes adicionais).
-
Selecione Ferramentas > Plataformas Java.
-
Clique na guia Javadoc.
-
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.
-
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:
-
Selecione o Projeto MyLib.
-
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. Enviar Feedback neste Tutorial
Próximas Etapas
Para obter mais informações sobre o uso do NetBeans IDE para desenvolver aplicações Java SE, consulte os seguintes recursos:
-
Criando Projetos Java em Desenvolvendo Aplicações com o NetBeans IDE