Criando um projeto de biblioteca de classe Java

1. Escolha Arquivo > Novo projeto (Ctrl-Shift-N). Em Categorias, selecione Java. Em Projetos, selecione Biblioteca de classes Java. Clique em Próximo.
2. Em Nome do projeto, digite MyLib. Altere Local de projeto para qualquer diretório no computador. De agora em diante, este tutorial se refere a esse diretório como NetBeans_projects.

   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 verificaçã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 Terminar. O projeto MyLib será exibido nas janelas Projetos e Arquivos.

Criando um projeto de aplicativo Java

1. Escolha Arquivo > Novo projeto. Em Categorias, selecione Java. Em Projetos, selecione Aplicativo Java. Clique em Próximo.
2. Em Nome do projeto, digite MyApp. Certifique-se de que o Local do projeto esteja definido como NetBeans_projects.
3. (Opcional) Marque a caixa de verificação Utilizar pasta dedicada para armazenar bibliotecas.
4. Insira acrostic.Main como classe principal.
5. Verifique se as caixas de verificação Definir como projeto principal e Criar classe principal estão marcadas.
6. Clique em Terminar. 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 o autocompletar de 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.

   

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á criado 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 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 Terminar. LibClass.java será aberto no Editor de código-fonte.
2. Em LibClass.java, coloque o cursor na linha após a instrução (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, é possível ver os recursos autocompletar de código do Editor de código-fonte e o modelo (abreviação) de código.

1. Selecione a aba Main.java no Editor de código-fonte. Expanda MyApp > Pacotes de código-fonte > acróstico na janela Projetos e clique duas vezes em Main.java, se ele ainda não estiver aberto.
2. Exclua o comentário // lógica do aplicativo 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á o autocompletar de código para transformar Li em LibClass.

4. Pressione Ctrl-Espaço para abrir a caixa de autocompletar de 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.

   Nota: o IDE também abrirá uma caixa acima da caixa de autocompletar de 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 de autocompletar de 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.

Nota: 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.

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 o aplicativo:

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 o aplicativo

Agora que você criou o aplicativo e forneceu os argumentos de tempo de execução para o aplicativo, pode testar a execução do aplicativo no IDE.

Para executar o aplicativo 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).

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 padrão. 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, exclua o corpo do método public void testAcrostic().
4. No lugar das linhas excluídas, 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 aba 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 aba 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 o aplicativo

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

Para executar o aplicativo 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 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. A matriz de strings contém a frase inserida como argumentos do comando.
4. Pressione F7 (ou selecione Depurar > Passar dentro) 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 o aplicativo

O comando construir principal no IDE é o comando Limpar e construir. O comando Limpar e construir exclui anteriormente as classes compiladas e outros artefatos de construção e, em seguida, reconstroi todo o projeto a partir do rascunho.

Notas: há também um comando Construir, que não exclui os antigos artefatos de construção, mas que está desativado por padrão. Consulte a seção Compilar ao salvar no guia Criando, importando e configurando projetos Java para obter mais informações.

Para construir o aplicativo:

• 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 excluídas ("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 visualizar 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 em 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.

Nota: é possível visualizar 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 o aplicativo fora do IDE

Para executar o aplicativo 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 comando, digite a seguinte instrução:

                   java -jar MyApp.jar However we all feel zealous    

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

Result = Hello
            

Distribuindo o aplicativo para outros usuários

Agora que verificou que o aplicativo funciona fora do IDE, você está pronto para distribuir o aplicativo.

Para distribuir o aplicativo:

1. em seu sistema, crie um arquivo zip que contenha o arquivo JAR do aplicativo (MyApp.jar) e a pasta lib correspondente que contém o MyLib.jar.
2. Envie o arquivo para as pessoas que utilizarão o aplicativo. 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 o aplicativo fora do IDE acima.

Tornando o Javadoc disponível no IDE

Para visualizar 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 visualizar 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. baixe o 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 aba 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 navegador que exibe o Javadoc.