Criando uma nova biblioteca de classes Java

1. Escolha Arquivo > Novo projeto (Ctrl-Shift-N). Em Categorias, selecione Java. Em Projetos, selecione Biblioteca de classes Java e clique em Próximo.
2. Em Nome do projeto, insira MyLib. Altere Local do projeto para qualquer diretório no computador. De agora em diante, nos referiremos 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: /NetBeans_projects/MyLib/

3. Clique em Terminar. O projeto MyLib será exibido nas janelas Projetos e Arquivos.

Criando uma aplicação Java

1. Escolha Arquivo > Novo projeto. Em Categorias, selecione Java. Em Projetos, selecione Aplicação Java e clique em Próximo.
2. Em Nome do projeto, insira MyApp. Certifique-se de que o Local do projeto está definido como NetBeans_projects.
3. Insira acrostic.Main como classe principal.
4. Verifique se as caixas de verificação Definir como projeto principal e Criar classe principal estão marcadas.
5. Clique em Terminar. O projeto MyApp será exibido na janela Projeto e Main.java será exibido no Editor de código-fonte.

Configurando o classpath de compilação

Já que MyApp vai depender de uma classe em MyLib, temos que adicionar MyLib ao classpath de MyApp. Fazer isso garantirá que as classes no projeto MyApp podem se referir a classes no projeto MyLib sem causar erros de compilação. Além disso, isso permitirá que você use auto-completar de código no projeto MyApp para preencher o código com base no projeto MyLib.

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.
2. Procure NetBeans_projects/ 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á construído quando construirmos e executarmos 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 declaração da 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, adicionaremos código a Main.java. Ao fazê-lo, demonstraremos os recursos auto-completar de código do Editor de código-fonte e o modelo de código (abreviação).

1. Selecione a aba Main.java no Editor de código-fonte. Se ele ainda não estiver aberto, expanda MyApp > Pocotes de fontes > acróstico na janela Projetos e clique duas vezes em Main.java.
2. Exclua o comentário // TODO code application logic here 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, mostraremos como usar auto-completar de código para transformar Li em LibClass.

4. Pressione Ctrl-Barra de espaços para abrir a caixa de auto-completar de código.

   Aparece uma lista resumida de formas possíveis de completar a palavra. Entretanto, 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 de auto-completar de código que exibe informações de Javadoc da classe ou do pacote selecionado. Como não há informações de Javadoc para a maioria dos pacotes, a caixa exibirá uma mensagem "Não é possível localizar Javadoc" até que você atinja uma classe Java.

7. No método principal, insira um ponto depois de LibClass. A caixa de auto-completar de código se abrirá novamente.
8. Selecione o método acrostic(String[]args) e pressione Enter. O IDE preenche o método acrostic 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 ficar dessa forma:

    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 a aspas finais. A linha final deve ficar dessa forma:

    System.out.println("Result = "+result);

12. Pressione Ctrl-S para salvar o arquivo.

Definindo a classe principal e os argumentos de execuçã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. Observe que a classe principal já está definida como acrostic.Main.
2. Indique However we all feel zealous no campo Argumentos e clique em OK.

Executando o projeto principal

1. Selecione Executar > Executar projeto principal (F6) no menu Executar.
2. Clique duas vezes na janela Saída para maximizá-la e poder ver toda a saída. Observe que Ant constrói MyLib.jar primeiro e, em seguida, compila MyApp usando-a. Finalmente, é impressa a saída a partir do programa, Result = Hello (o acróstico da expressão foi passado para o progrma como um argumento).
3. Selecione a janela Arquivos e expanda a pasta do projeto MyApp. Os arquivos de classe construídos ficam na pasta build.
4. Pressione F6 para executar o programa novamente. Nada novo precisará ser compilado, mas o programa será executado.

Limpando e construindo o projeto

Se você construir um projeto e depois alterar as classes, recomendamos remover todos os artefatos construídos do sistema e criar uma nova construção da aplicação. Você pode fazer isso com o comando Limpar e Construir.

1. Escolha Construir > Limpar e construir projeto principal (Shift-F11). Os projetos MyLib e MyApp serão limpos e reconstruídos como parte do processo.
2. Clique com o botão direito do mouse no nó do projeto MyLib na janela Projetos e selecione Limpar projeto. Somente o projeto MyLib será limpo.

Construindo um projeto individual

1. Clique com o botão direito do mouse no nó do projeto MyLib na janela Projetos.
2. Selecione Construir projeto no menu contextual.

Gerando o Javadoc

1. Selecione o projeto MyLib.
2. No menu principal do IDE, selecione Construir > Gerar Javadoc para "MyLib".

   O IDE exibe a saída de Javadoc na janela Saída e o navegador da Web se abrirá exibindo o Javadoc.

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 acrostic().
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 "MyLib" (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 selecione Executar > Executar arquivo  > Testar "LibClass.java" no menu Executar.

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

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

Depurando o projeto

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. Escolha Executar > 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 e expanda o nó args. A matriz de strings contém a frase inserida como argumentos do comando.
4. Clique em Passar dentro (F7) na barra de ferramentas para acessar o programa e observar o acróstico que está sendo construído.

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