netbeans ide

44
Tutorial de início rápido de Java do NetBeans IDE Bem-vindo ao NetBeans IDE! Este tutorial oferece uma introdução simples e rápida ao fluxo de trabalho do NetBeans IDE, orientando você na criação de um aplicativo de console simples do "Hello world" de Java. Após concluir este tutorial, você terá adquirido um conhecimento geral sobre como criar e executar aplicativos no IDE. Este tutorial leva menos de 10 minutos para ser concluído. Depois de concluir este tutorial, é possível ir para as trilhas do aprendizado, que são vinculadas a partir da página Documentação, treinamento e suporte . Os caminhos do aprendizado oferecem tutoriais abrangentes que realçam uma ampla gama de recursos do IDE e técnicas de programação para uma variedade de tipos de aplicativos. Se não desejar criar um aplicativo "Hello world", é possível ignorar este tutorial e ir direito para os caminhos do aprendizado. Conteúdo Configurando o projeto Adicionando código ao arquivo de código-fonte gerado Compilando e executando o aplicativo Construindo e implantando o aplicativo Próximas etapas Para concluir este tutorial, são necessários os seguintes recursos e softwares. Software ou recurso Versão necessária NetBeans IDE versão 6.9 e 7.0 Java Development Kit (JDK) versão 6

Upload: cleber-silva

Post on 05-Jul-2015

421 views

Category:

Documents


5 download

TRANSCRIPT

Page 1: NetBeans IDE

Tutorial de início rápido de Java do NetBeans IDEBem-vindo ao NetBeans IDE!

Este tutorial oferece uma introdução simples e rápida ao fluxo de trabalho do NetBeans IDE, orientando você na criação de um aplicativo de console simples do "Hello world" de Java. Após concluir este tutorial, você terá adquirido um conhecimento geral sobre como criar e executar aplicativos no IDE.

Este tutorial leva menos de 10 minutos para ser concluído.

Depois de concluir este tutorial, é possível ir para as trilhas do aprendizado, que são vinculadas a partir da página Documentação, treinamento e suporte. Os caminhos do aprendizado oferecem tutoriais abrangentes que realçam uma ampla gama de recursos do IDE e técnicas de programação para uma variedade de tipos de aplicativos. Se não desejar criar um aplicativo "Hello world", é possível ignorar este tutorial e ir direito para os caminhos do aprendizado.

Conteúdo

Configurando o projeto Adicionando código ao arquivo de código-fonte gerado

Compilando e executando o aplicativo

Construindo e implantando o aplicativo

Próximas etapas

Para concluir este tutorial, são necessários os seguintes recursos e softwares.

Software ou recurso Versão necessáriaNetBeans IDE versão 6.9 e 7.0Java Development Kit (JDK) versão 6

Configurando o projeto

Para criar um projeto do IDE:

1. Inicie o NetBeans IDE.2. No IDE, escolha Arquivo > Novo projeto (Ctrl-Shift-N), como mostrado na figura abaixo.

Page 2: NetBeans IDE

3. No assistente para Novo projeto, expanda a categoria Java e selecione Aplicação Java, como mostrado na figura abaixo. Em seguida clique em Próximo.

4. Na página Nome e localização do assistente, adote o procedimento a seguir (como mostrado na figura abaixo):

o no campo Nome do projeto, digite HelloWorldApp.

o Deixe desmarcada a caixa de verificação Utilizar pasta dedicada para armazenar bibliotecas.

o No campo Criar classe principal, digite helloworldapp.HelloWorldApp.

o Deixe marcada a caixa de verificação Definir como projeto principal.

Page 3: NetBeans IDE

5. Clique em Terminar.

O projeto é criado e aberto no IDE. Agora você deve ver os seguintes componentes:

A janela Projetos, que contém uma visualização em árvore dos componentes do projeto, incluindo arquivos de código-fonte, bibliotecas de que seu código depende, e assim por diante.

A janela Editor de código-fonte com um arquivo chamado HelloWorldApp é aberta.

A janela Navegador, que você pode utilizar para navegar rapidamente entre elementos dentro da classe selecionada.

A janela Tarefas, que lista os erros de compilação bem como outras tarefas marcadas com palavras-chave como XXX e TODO.

Page 4: NetBeans IDE

Adicionando código ao arquivo de origem gerado

Como a caixa de verificação Criar classe principal foi marcada no assistente de Novo projeto, o IDE criou uma classe principal de esqueleto. Você pode adicionar a mensagem "Hello World!" ao código de esqueleto substituindo a linha:

// TODO lógica de aplicação do código aqui

com a linha: System.out.println("Hello World!");

Salve a alteração escolhendo Arquivo > Salvar.

O arquivo deve ter uma aparência semelhante à seguinte amostra de código.

/* * To change this template, choose Tools | Templates * and open the template in the editor. */

package helloworldapp;

/** * * @author <your name> */public class HelloWorldApp {

/** * @param args the command line arguments */

Page 5: NetBeans IDE

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

}

Compilando e executando o programa

Devido ao recurso Compilar ao salvar do IDE, não é necessário compilar manualmente o projeto para que seja executado no IDE. Quando um arquivo de código-fonte Java é salvo, ele é compilado automaticamente pelo IDE.

O recurso Compilar na gravação pode ser desativado na janela Propriedades do projeto. Clique com o botão direito do mouse no projeto e selecione Propriedades. Na janela Propriedades, escolha a aba Compilação. A caixa de verificação Compilar ao salvar está bem na parte superior. Note que, na janela Propriedades do projeto, é possível definir várias configurações para o projeto: bibliotecas do projeto, empacotamento, construção, execução, etc.

Para executar o programa:

Escolha Executar > Executar projeto principal (F6).

A figura abaixo mostra o que você deve ver agora.

Parabéns! Seu programa funciona!

Se houver erros de compilação, eles são marcados com glifos vermelhos nas margens esquerda e direita do Editor de código-fonte. Os glifos da margem esquerda indicam os erros das linhas correspondentes. Os glifos da margem direita mostram todas as áreas do arquivo que apresentam erros, incluindo os erros das linhas que não estão visíveis. É possível passar o mouse sobre a marca do erro para ver a descrição deste erro. É possível clicar em um glifo da margem direita para ir para a linha que apresenta o erro.

Construindo e implantando o aplicativo

Depois de escrever e executar o teste do aplicativo, você pode utilizar o comando Limpar e construir para construir o aplicativo para deployment. Quando o comando Limpar e construir é utilizado, o IDE executa um script de construção que realiza as tarefas a seguir:

exclui os arquivos compilados anteriormente e outras saídas de construção. Recompila o aplicativo e constrói um arquivo JAR que contém arquivos compilados.

Para construir seu aplicativo:

Escolha Executar > Limpar e construir projeto principal (Shift-F11)

Page 6: NetBeans IDE

É possível ver as saídas de construção abrindo a janela Arquivos e expandindo o nó

HelloWorldApp. O arquivo bytecode compilado HelloWorldApp.class está no subnó build/classes/helloworldapp. O arquivo JAR implantável que contém o HelloWorldApp.class está no nó dist.

Para informações sobre como executar o aplicativo na linha de comando para o seu sistema operacional, consulte a lição "O aplicativo 'Hello World'" dos tutoriais Java.

 

Envie-nos seus comentários

 

Próximas etapas

Agora você sabe como executar algumas das tarefas de programação mais comuns no IDE.

Para saber mais sobre o fluxo de trabalho do IDE para o desenvolvimento de aplicativos Java, incluindo o gerenciamento de classpath, consulte Desenvolvendo e implantando aplicativos gerais Java.

Para obter mais informações sobre a implantação de aplicativos de área de trabalho Java, consulte Empacotando e implantando aplicativos de área de trabalho Java.

Para localizar informações específicas do tipo de aplicativo que você está desenvolvendo, utilize a trilha do aprendizado do NetBeans IDE para esse tipo de aplicativo. Cada trilha do aprendizado contém uma série de tutoriais e guias que variam em escopo do básico ao avançado. As seguintes trilhas do aprendizado estão disponíveis:

Desenvolvimento geral em Java

Integração com ferramentas e serviços externos

Aplicativos de GUI em Java

Aplicativos PHP

Desenvolvimento de módulo e a plataforma NetBeans

Aplicativos C/C++

Aplicativos móveis

Page 7: NetBeans IDE

Aplicativos de serviço da Web

Aplicativos Web Java e Java EE http://netbeans.org/kb/docs/java/quickstart_pt_BR.html

Desenvolvendo e implantando aplicativos Java em geralO breve tutorial a seguir o guia através de algumas das etapas básicas do desenvolvimento de um aplicativo Java SE no NetBeans IDE. Este tutorial pressupõe que você já tenha alguma familiaridade com o desenvolvimento de aplicativos Java. Ao longo do caminho, será possível ver alguns dos recursos do IDE que simplificam o desenvolvimento de aplicativos.

Será criado um aplicativo 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 fazer um tutorial "Olá, mundo" mais rápido, veja o Tutorial de introdução rápida do NetBeans IDE Java.

Conteúdo

Configuração do projeto Criando e editando o código-fonte Java

Compilando e executando o aplicativo

Testando e depurando o aplicativo

Construindo e implantando o aplicativo

Outras tarefas comuns

Próximas etapas

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

Software ou recurso Versão necessáriaNetBeans IDE Versão 6.9, 6.8 ou 6.7 Java Development Kit (JDK) versão 6

Configuração do projeto

O aplicativo que será criado conterá dois projetos:

Um projeto de biblioteca de classe Java, no qual será criada uma classe de utilitário.

Page 8: NetBeans IDE

Um projeto de aplicativo Java com uma classe principal que implementa um método a partir da classe de utilitário do projeto da biblioteca.

Depois de criar os projetos, o projeto da biblioteca será adicionado ao classpath do projeto do aplicativo. Em seguida, você codificará o aplicativo. O projeto da biblioteca conterá uma classe de utilitário com um método de acróstico. O método de acróstico toma uma matriz 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 de acróstico e passa as palavras que são inseridas como argumentos quando o aplicativo é executado.

Nota: falando estritamente, dois projetos não são necessários para um aplicativo tão simples. Este tutorial utiliza dois projetos para demonstrar os recursos que você pode precisar para um aplicativo mais complexo.

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 do projeto para qualquer diretório no computador. De agora em diante, este tutorial se refere a esse diretório como NetBeans_projects.

Nota: o caminho especificado acima deve estar como a seguir no campo Pasta do projeto do assistente: /NetBeans_projects/MyLib/

3. (Opcional) Selecione 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 está 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.

Page 9: NetBeans IDE

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á 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 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 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

Page 10: NetBeans IDE

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.

Compilando e executando o aplicativo

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

Nota: por padrão, os projetos foram criados com o recurso Compilar ao salvar ativado, assim, não é necessário compilar seu código antes de executar o aplicativo no IDE. Para obter mais informações sobre o recurso 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

Page 11: NetBeans IDE

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).

Testando e depurando o aplicativo

Agora um teste do projeto será criado e executado utilizando JUnit e, em seguida, o aplicativo será executado 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 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:

5. System.err.println("Running testAcrostic...");6. String result = LibClass.acrostic(new String[]7. {"fnord", "polly", "tropism"});

assertEquals("Correct value", "foo", result);

8. 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.

Page 12: NetBeans IDE

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

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

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:

Page 13: NetBeans IDE

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).

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.

Page 14: NetBeans IDE

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.

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 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. Nestes casos, os recursos do Javadoc devem ser associados manualmente ao IDE.

Para tornar a documentação da API Javadoc disponível para o comando Exibir 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.

http://netbeans.org/kb/docs/java/javase-intro_pt_BR.html

Page 15: NetBeans IDE

Criando, importando e configurando projetos JavaEste guia fornece uma visão geral dos principais recursos do NetBeans IDE para instalar e configurar projetos Java. Além disso, ele fornece informações sobre como efetuar a configuração personalizada de scripts de construção gerados pelo IDE.

Para concluir este tutorial, são necessários os seguintes recursos e softwares.

Conteúdo

Conceitos básicos do projeto o Projetos

o Ant

Criando um projeto

Importando um projeto

o Importando em espaço de trabalho Eclipse

o Configurando um projeto Java com base em código-fonte existente

o Configurando um projeto JavaFX com base em código-fonte existente

o Configurando um projeto Web com base em código-fonte existente

o Projetos de forma livre

Configurando o classpath e outras definições do projeto

o Definindo o projeto principal

o Configurando o JDK de destino de um projeto

o Gerenciando o classpath do projeto

o Gerenciando dependências entre projetos

o Compartilhando bibliotecas do projeto

o Tornando o Javadoc do JDK disponível no IDE

o Habilitando o Java Web Start

Construindo aplicativos

o Construindo projetos, pacotes e arquivos

o Compilar ao salvar

o Corrigindo erros de compilação

o Filtrando arquivos de saída

Page 16: NetBeans IDE

Executando aplicativos

o Executando projetos e arquivos

o Personalizando as opções em tempo de execução

o Definindo o classpath de tempo de execução

o Definindo a classe principal e os argumentos de tempo de execução

o Definindo os argumentos JVM

Personalizando o script de construção

o Editando e executando scripts do Ant

o Escrevendo tarefas personalizadas do Ant

Consulte também

Software ou recurso Versão necessáriaNetBeans IDE versão 6.7, 6.8 ou 6.9Java Development Kit (JDK) versão 6

Conceitos básicos do projeto

Esta seção fornece uma visão geral de algumas informações detalhadas sobre o sistema de projeto do IDE.

Projetos

No IDE, você sempre trabalha dentro de um projeto. Além dos arquivos de código-fonte, um projeto do IDE contém metadados que pertencem no classpath, como construir e executar o projeto e assim por diante. O IDE armazena as informações do projeto em uma pasta do projeto que inclui um script de construção do ANT e um arquivo de propriedades que controla a construção e as configurações de execução e um arquivo project.xml que mapeia os alvos do Ant com comandos do IDE.

Nota: embora o IDE coloque diretórios de código-fonte na pasta de projeto por padrão, seus diretórios de código-fonte não necessariamente precisam estar localizados na pasta do projeto.

Ant

O Apache Ant é uma ferramenta de compilação utilizada para padronizar e automatizar a compilação, além de executar ambientes para desenvolvimento. O sistema do projeto do IDE tem base direta no Ant. Todos os comandos do projeto, como Limpar e construir o projeto e Depurar, chamam alvos no script do Ant do projeto. Portanto, é possível construir e executar um projeto fora do IDE, exatamente como é construído e executado dentro do IDE.

Não é necessário saber como trabalhar no Ant com o IDE. É possível definir todas as opções básicas de compilação e tempo de execução na caixa de diálogo Propriedades do projeto no projeto e o IDE atualiza automaticamente o script do Ant do projeto. Se você está familiarizado com o Ant, poderá personalizar um script padrão do Ant do projeto ou escrever seu próprio script do Ant para um projeto.

Criando um projeto

Para criar um novo projeto:

escolha Arquivo > Novo projeto (Ctrl-Shift-N).

Page 17: NetBeans IDE

Quando o assistente para Novo projeto aparecer, selecione o modelo correto para seu projeto e complete as etapas restantes do assistente. Na versões mais recentes do NetBeans IDE 6.7, o ícone do modelo do projeto pode ser exibido em cinza, o que significa que este tipo de projeto não foi ativado. Prossiga com a criação do projeto e esta funcionalidade será ativada no IDE.

O IDE contém os seguintes modelos de projeto padrão para aplicativos de área de trabalho Java da Web:

Aplicativo Java. Cria um projeto esqueleto Java SE com uma classe principal. Consulte Desenvolvendo e implantando aplicativos Java gerais para obter um breve tutorial que utiliza este modelo.

Aplicativo de área de trabalho Java. Cria um aplicativo com base no Swing Application Framework. Os esqueletos são oferecidos para aplicativos básicos da área de trabalho, que fazem uso das bibliotecas Beans Binding e Java Persistence API. Consulte Construindo um aplicativo de banco de dados da área de trabalho Java para obter um exemplo que utiliza este modelo.

Biblioteca de classes Java. Cria uma biblioteca de classes esqueleto Java sem uma classe principal. Consulte Desenvolvendo e implantando aplicativos Java gerais para obter um breve tutorial que utiliza este modelo.

Projeto Java com código-fonte existente. Cria um projeto Java SE com base em seu próprio código-fonte Java. Consulte Configurando um projeto Java com base em código-fonte existente abaixo.

Aplicativo Web. Cria um aplicativo Web esqueleto, incluindo opções para adicionar diversas estruturas Web. Consulte Introdução ao desenvolvimento de aplicativos Web para obter um exemplo que utiliza este modelo.

Aplicativo Web com código-fonte existente. Cria um projeto Web com base em seu próprio código-fonte Web e Java. Consulte Configurando um projeto Web com base em código-fonte existente abaixo.

Além disso, o IDE também contém modelos para módulos EJB, aplicativos corporativos, aplicativos Java ME e mais.

As categorias de projetos Java e Web também têm modelos de projeto de formato livre. Os modelos de formato livre permitem o uso de um script do Ant existente para um projeto, mas requerem a configuração manual. Consulte Projetos de formato livre abaixo.

Quando você termina de criar um projeto, ele é aberto no IDE com sua estrutura lógica exibida na janela Projetos e sua estrutura de arquivo exibida na janela Arquivos:

A janela Projetos é o ponto de entrada principal para as fontes do projeto. Ela mostra uma visualização lógica do conteúdo importante do projeto como pacotes Java e páginas da Web. É possível clicar com o botão direito do mouse em qualquer nó do projeto para acessar um menu suspenso de comandos para construir, executar e depurar o projeto, bem como abrir a caixa de diálogo Propriedades do projeto. A janela Projetos pode ser aberta ao escolher Janela > Projetos (Ctrl-1).

A janela Arquivos mostra uma visualização de seus projetos com base em diretório, incluindo arquivos e pastas que não são exibidos na janela Projetos. A partir da janela Arquivos, é possível abrir e editar os arquivos de configuração do projeto, como o script de construção do projeto e o arquivo de propriedades. Também é possível visualizar a saída da construção como classes compiladas, arquivos JAR, arquivos WAR e documentação Javadoc gerada. A janela Arquivos pode ser aberta ao escolher Janela > Arquivos (Ctrl-2).

Page 18: NetBeans IDE

Nota: se for necessário acessar os arquivos e diretórios que estejam fora dos diretórios do projeto, é possível utilizar a janela Favoritos. A janela Favoritos pode ser aberta ao escolher Janela > Favoritos (Ctrl-3). É possível adicionar qualquer pasta ou arquivo à janela Favoritos clicando com o botão direito do mouse na janela Favoritos e escolhendo Adicionar aos favoritos.

Importando um projeto

Esta seção mostra como manipular a importação inicial de projetos para o IDE.

Importando um espaço de trabalho Eclipse

Para projetos Eclipse, é possível utilizar o assistente Importar projeto Eclipse para ajudá-lo a criar projetos NetBeans a partir de projetos em um espaço de trabalho Eclipse e para importar classpaths do projeto e outras configurações. Quando o assistente Importar projeto Eclipse é utilizado, não é necessário utilizar manualmente criar e configurar o projeto NetBeans. Abra o assistente escolhendo Arquivo > Importar projeto > Projeto Eclipse. Consulte Importando projetos Eclipse no NetBeans IDE. para obter informações sobre como funciona o assistente e como você pode trabalhar simultaneamente em projetos Eclipse e NetBeans.

Configurando um projeto Java com base em código-fonte existente

Para outros projetos Java desenvolvidos fora do NetBeans, é possível utilizar o modelo "Código-fonte existente" no assistente Novo projeto para criar um projeto NetBeans. No assistente, você identifica a localização do código-fonte e especifica a localização para os metadados do projeto NetBeans. Então a caixa de diálogo Propriedades do projeto é utilizada para configurar o projeto.

Para configurar um projeto NetBeans para um aplicativo Java existente:

1. escolha Arquivo > Novo projeto (Ctrl-Shift-N). 2. Escolha Java > Projeto Java com código-fonte existente. Clique em Próximo.

3. Na página Nome e localização do assistente, siga as etapas seguir:

Page 19: NetBeans IDE

o Digite um nome de projeto.

o (Opcional) Altere a localização da pasta do projeto.

o (Opcional) Altere o nome do script de construção utilizado pelo IDE. Isso pode ser desejável se já houver um script denominado como build.xml que é utilizado para construir o código-fonte.

o (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.

o (Opcional) Marque a caixa de verificação Definir como projeto principal. Quando esta opção é selecionada, os atalhos de teclado para os comandos como Limpar e construir o projeto principal (Shift-F11) se aplicam à este projeto.

4. Clique em Próximo para avançar para a página Códigos-fonte existentes do assistente.

5. No painel Pasta de pacotes de código-fonte clique em Adicionar pasta. A seguir, navegue para seu código-fonte e selecione as raízes do código-fonte.

Quando uma pasta contendo o código-fonte é adicionada, é necessário adicionar a pasta que contém a pasta mais alta em sua árvore do pacote. Por exemplo, para o pacote com.mycompany.myapp.ui, você adiciona a pasta que contém a pasta com.

6. (Opcional) No painel Pastas de pacote de teste, clique em Adicionar pasta para selecionar a pasta contendo as pastas do pacote JUnit.

7. (Opcional) Na página Inclui e exclui do assistente, insira os padrões do nome do arquivo somente para os arquivos que deveriam ser incluídos ou excluídos do projeto. Todos os arquivos em suas raízes de código-fonte são incluídos por padrão.

8. Clique em Terminar.

O projeto será exibido nas janelas Projetos e Arquivos.

Configurando um projeto JavaFX com base em código-fonte existente

Você cria uma projeto JavaFX a partir de um aplicativo JavaFX existente desenvolvido fora do NetBeans IDE. Esta opção funciona se o plug-in JavaFX estiver instalado ou se a opção de download do JavaFX do IDE estiver sendo utilizada.

Para configurar um projeto NetBeans para um aplicativo Java existente:

1. escolha Arquivo > Novo projeto (Ctrl-Shift-N). 2. Escolha Java > Aplicativo de script JavaFX e clique em Próximo.

3. Na página Nome e localização do assistente, siga as etapas seguir:

o Digite um nome de projeto.

o (Opcional) Especifique a localização da pasta do projeto.

o Selecione o botão de opção De código-fonte.

o Clique em Adicionar pasta e especifique a pasta que contém seus arquivos de código-fonte de aplicativo JavaFX existente.

o (Opcional) Marque a caixa de verificação Definir como projeto principal. Quando essa opção é selecionada, os atalhos de teclado para os comandos como Limpar e construir o projeto principal (Shift-F11) se aplicam à este projeto.

Page 20: NetBeans IDE

4. Clique em Terminar.

O projeto Java FX é exibido nas janelas Projetos e Arquivos.

Configurando um projeto Web com base em código-fonte existente

Para projetos Web desenvolvidos fora do NetBeans, é possível utilizar o modelo "Código-fonte existente" no assistente Novo projeto para criar um projeto NetBeans. No assistente, você identifica a localização do código-fonte e especifica a localização para os metadados do projeto NetBeans. Então a caixa de diálogo Propriedades do projeto é utilizada para configurar o projeto.

Nota: se o projeto foi originalmente desenvolvido no Eclipse, é possível economizar tempo ao utilizar o assistente Importar projeto Eclipse ao invés do assistente Novo projeto. O assistente Importar projeto Eclipse permite importar simultaneamente múltiplos projetos, incluindo suas configurações. Consulte Importando projetos Eclipse no NetBeans IDE.

Para configurar um projeto NetBeans para um aplicativo Web existente:

1. escolha Arquivo > Novo projeto (Ctrl-Shift-N). 2. Escolha Java Web > Aplicativo Java com código-fonte existente. Clique em Próximo.

3. Na página Nome e localização do assistente, siga as etapas a seguir:

o No campo Localização, insira a pasta que contém as pastas raízes do código-fonte do aplicativo Web e as pastas da página Web.

o Digite um nome de projeto.

o (Opcional) Altere a localização da pasta do projeto.

4. (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 no NetBeans IDE para obter mais informações sobre essa opção.

5. (Opcional) Marque a caixa de verificação Definir como projeto principal. Quando essa opção é selecionada, os atalhos de teclado para os comandos como Limpar e construir o projeto principal (Shift-F11) se aplicam à este projeto.

6. Clique em Próximo para avançar para a página Servidor e configurações do assistente.

7. (Opcional) Adicione o projeto em um aplicativo corporativo existente.

8. Selecione um servidor no qual implantar. Se o servidor que você deseja não aparece, clique em Adicionar para registrar o servidor no IDE.

9. (Opcional) Marque a pasta de biblioteca dedicada para a caixa de verificação Arquivos JAR do servidor. Esta opção somente está disponível se você designou uma pasta dedicada para bibliotecas na página anterior do assistente.

10. Defina o nível do código-fonte para a versão Java na qual deseja que o aplicativo seja executado.

11. (Opcional) Ajuste o caminho do contexto. O caminho do contexto tem base no nome do projeto por padrão.

12. Clique em Próximo para avançar para a página Códigos-fonte existentes e bibliotecas do assistente.

13. Verifique todos os campos na página, como os valores para a Pasta de páginas Web e Pastas do pacote do código-fonte.

14. Clique em Terminar.

Page 21: NetBeans IDE

O projeto é exibido nas janelas Projetos e Arquivos.

Projetos de formato livre

Também há modelos de projeto disponíveis para projetos de formato livre. Em projetos de formato livre, o IDE utiliza alvos em um script do Ant existente para construir, executar, limpar, testar e depurar o aplicativo. Se um script do Ant não contém alvos para algumas destas funções, as funções estão indisponíveis para o projeto. Para implementar essas funções, você escreve alvos em seu script do Ant ou em um script secundário do Ant.

Em geral, é melhor utilizar modelos padrão de projeto "com códigos-fonte existentes" para importar projetos. Para projetos Eclipse, é melhor utilizar o recurso Importar projeto, que cria e configura um projeto padrão por você. Os projetos padrão são mais fáceis de manter a longo prazo. No entanto, os modelos de projeto de formato livre são úteis se você possuir um projeto existente com base no Ant com uma configuração complexa ou idiossincrática, que não pode ser duplicado dentro de um projeto padrão. Por exemplo, se um projeto com múltiplas raízes de código-fonte estiver sendo importado, cada um tendo um classpath diferente e se não puder dividir as raízes de código-fonte em diferentes projetos, pode ser necessário utilizar um modelo de projeto de formato livre.

Este guia foca em projetos padrão. Para mais informações sobre como configurar projetos de formato livre, consulte Configuração avançada de projeto de formato livre

Configurando o classpath e outras definições do projeto

Esta seção cobre as tarefas mais comuns para configurar um projeto, como a configuração do JDL alvo do projeto, a configuração do classpath, a criação de dependências entre projetos e o compartilhamento de bibliotecas entre projetos e usuários.

Definindo o projeto principal

Quando é desenvolvido um aplicativo grande que consiste em diversas pastas de código-fonte, é comum dividir o seu código em projetos separados. Normalmente, um destes projetos serve como o ponto de entrada para seu aplicativo. Para informar ao IDE qual projeto é o ponto de entrada principal do aplicativo, defina um projeto como o projeto principal. O IDE fornece comandos que agem no projeto principal. Por exemplo, a execução do comando Limpar e construir o projeto principal constroi o projeto principal e todos os seus projetos necessários.

Para definir um projeto como o projeto principal:

clique com o botão direito do mouse no nó do projeto na janela Projetos e escolha Definir como o projeto principal.

Somente um projeto por vez pode ser o projeto principal.

Configurando o JDK de destino de um projeto

No IDE, é possível registrar várias plataformas Java e anexar Javadoc e código-fonte a cada plataforma. Alternar o JDK de destino de um projeto padrão faz o seguinte:

Oferece as novas classes do JDK de destino para o autocompletar de código. Se disponível, exibe o código-fonte do JDK de destino e a documentação do Javadoc.

Utiliza os executáveis do JDK de destino (javac e java ) para compilar e executar a aplicação.

Compila o código-fonte nas bibliotecas do JDK de destino.

Page 22: NetBeans IDE

O IDE utiliza a versão da plataforma Java SE (JDK), na qual o IDE é executado como a plataforma Java padrão para projetos IDE por padrão. É possível visualizar a versão do JDK do IDE escolhendo Ajuda > Sobre e clicando na aba Detalhe. A versão do JDK é listada no campo Java.

Para executar o IDE com uma versão diferente do JDK:

inicie o IDE com a chave a seguir a partir da linha de comando.

--jdkhome jdk-home-dir

Alternativamente, defina o JDK no arquivo /etc/netbeans.conf que está localizado na pasta de instalação do IDE.

Para registrar uma nova plataforma Java:

1. escolha Ferramentas > Gerenciador da plataforma Java, a partir do menu principal.2. Especifique a pasta que contém a plataforma Java, assim como o código-fonte e o Javadoc necessário

para a depuração.

Para alternar o JDK de destino de um projeto padrão:

1. Clique com o botão direito do mouse no nó do projeto e escolha Propriedades.2. Selecione o painel Bibliotecas.

3. Altere a propriedade Plataforma Java.

Gerenciando o classpath do projeto

A adição de um grupo de arquivos de classe a um classpath de projeto informa o IDE das classes a que o projeto deve ter acesso durante a compilação e a execução. O IDE também utiliza configurações de classpath para ativar o autocompletar de código, o realce automático de erros de compilação e a refatoração. É possível editar todas as instruções do classpath de um projeto existente na caixa de diálogo Propriedades do projeto.

Page 23: NetBeans IDE

Em projetos padrão Java, o IDE mantém classpaths separados para compilar e executar seu projeto, assim como para compilar e executar testes JUnit (para aplicativos Java SE). O IDE adiciona automaticamente tudo no classpath de compilação do projeto ao classpath do tempo de execução do projeto.

É possível modificar o classpath do projeto de uma das formas a seguir:

clique com o botão direito do mouse no nó do projeto, selecione a categoria Bibliotecas e modifique as entradas de classpath listadas.

Clique com o botão direito do mouse no nó Bibliotecas na janela Projetos e escolha Adicionar projeto, Adicionar biblioteca ou Adicionar JAR/Pasta.

Se houver arquivos de Javadoc e arquivos de código-fonte anexados a um arquivo JAR no Gerenciador de bibliotecas, o IDE adicionará automaticamente os arquivos de Javadoc e os arquivos de código-fonte ao projeto quando o arquivo JAR for registrado em um classpath do projeto. É possível entrar nas classes e procurar as páginas de Javadoc das classes sem configurar nada mais.

Gerenciando dependências entre projetos

Se seu aplicativo consiste em múltiplos projetos, terá que configurar as dependências de classpath entre os projetos. Normalmente, você configura um projeto principal contendo a classe do projeto principal (em projetos Java SE) e diversos projetos necessários. Um projeto requerido é um projeto que foi adicionado a outro classpath de projeto. Toda vez que limpa e constrói um projeto, o IDE também limpa e constrói os projetos necessários. O projeto do Javadoc necessário e o código-fonte também são disponibilizados para o projeto recebedor.

É possível adicionar quaisquer projetos necessários para o projeto ao clicar com o botão direito do mouse no nó Bibliotecas ou adicioná-los ao especificá-los na aba Bibliotecas na caixa de diálogo Propriedades do projeto.

Page 24: NetBeans IDE

Quando quiser adicionar um projeto necessário, selecione a pasta do projeto cujos arquivos JAR você deseja adicionar ao classpath (o seletor de arquivos exibe o ícone para as pastas do projeto IDE ( ). Ao adicionar projetos na caixa de diálogo Propriedades do projeto, assegure que a caixa de verificação Construir projetos no classpath esteja marcada.

Se quiser adicionar um projeto de formato livre para o classpath de um projeto padrão, terá que adicionar o arquivo JAR do projeto de formato livre para o classpath do projeto padrão. Para fazer isso, é preciso primeiro declarar todos os arquivos de saída do projeto de formato livre no painel Saída da caixa de diálogo Propriedades do projeto do projeto de formato livre.

Compartilhando bibliotecas do projeto

Como o sistema do projeto NetBeans IDE possui base em Ant, os projetos do NetBeans já são geralmente transferíveis entre usuários diferentes, independentemente de eles utilizarem o IDE ou não. Entretanto, por padrão, a forma pela qual o script de construção do projeto se refere às bibliotecas depende de vários fatores específicos para cada usuário, particularmente no caso de bibliotecas definidas na caixa de diálogo Gerenciador de bibliotecas.

Por exemplo, normalmente é possível colocar um projeto em um arquivo zip e dar o mesmo para que outro usuário o desempacote e o execute. Mas se o projeto depende de uma biblioteca personalizada especificada na caixa de diálogo Gerenciador de bibliotecas, outros podem inicialmente ter problemas para construir o projeto por causa das referências não solucionadas para a biblioteca personalizada.

Outra inconveniência potencial é que as bibliotecas são armazenadas em uma variedade de locais, com base em sua origem. As bibliotecas que vêm com o IDE são armazenadas em várias pastas diferentes na instalação do IDE. Os exemplos disso incluem as bibliotecas das extensões de layout do Swing, vinculação de beans e drivers de banco de dados.

Para solucionar esses problemas, é possível especificar uma pasta dedicada para bibliotecas do projeto. Além disso, você decide entre utilizar um caminho relativo ou caminho absoluto ao se referir a essas bibliotecas.

Essa flexibilidade torna mais fácil manipular as situações a seguir:

Ao criar um projeto é necessário torná-lo disponibilizável e construível para outros usuários, independentemente de eles utilizarem o IDE ou não. Eles precisam ser capazes de acessar o projeto através de um checkout de controle de versão ou descompactando um arquivo zip que você forneceu para eles. Eles devem ser capazes de construir o aplicativo sem configuração extra.

Você deve começar trabalhando em um projeto existente e aderir a um conjunto estrito de convenções relacionadas ao lugar onde as bibliotecas do projeto são armazenadas (e se os seus scripts de construção os acessam com uma referência relativa ou referência absoluta).

É possível definir uma pasta de bibliotecas dedicadas para projetos padrão Java SE, Web e Corporativo. É possível definir a pasta de bibliotecas ao criar o projeto (no assistente para Novo projeto) ou depois na aba Bibliotecas da caixa de diálogo Propriedades do projeto.

Para tornar as bibliotecas gerais do projeto Java compartilháveis durante a criação do projeto:

1. escolha Arquivo > Novo projeto.2. Na categoria Java do assistente, selecione um dos modelos padrão. Em seguida, clique em Próximo.

3. Na página Nome e localização do assistente, marque a caixa de verificação Utilizar pasta dedicada para armazenar bibliotecas.

4. No campo Bibliotecas, selecione a localização das bibliotecas a serem armazenadas.

Se as bibliotecas já estiverem incluídas no IDE, elas serão copiadas para a pasta designada.

Page 25: NetBeans IDE

Para tornar as bibliotecas do projeto Java EE ou da Web compartilháveis durante a criação do projeto:

1. escolha Arquivo > Novo projeto.2. Na categoria Web do assistente, selecione um dos modelos padrão. Em seguida, clique em Próximo.

3. Na página Nome e localização do assistente, marque a caixa de verificação Utilizar pasta dedicada para compartilhar bibliotecas.

4. No campo Bibliotecas, selecione a localização das bibliotecas a serem armazenadas.

Se as bibliotecas já estiverem incluídas no IDE, elas serão copiadas para a pasta designada.

5. (Opcional) Na página Servidor e configurações, selecione o botão de opção Copiar arquivos JAR do servidor para a pasta Bibliotecas.

Para tornar as bibliotecas de um projeto existente compartilháveis:

1. clique com o botão direito do mouse no nó do projeto e escolha Propriedades.2. Na caixa de diálogo Propriedades do projeto, marque o nó Bibliotecas.

3. No painel Bibliotecas, clique em Procurar para abrir o assistente pasta Novas bibliotecas.

4. Na página Pasta biblioteca do assistente, insira uma localização para as bibliotecas e clique em Próximo.

É possível inserir a localização como uma referência relativa ou uma referência absoluta.

5. No painel Ações do assistente, verifique a ação selecionada para cada biblioteca listada. Na maioria dos casos, o IDE detecta a ação mais apropriada para essa biblioteca.

As ações a seguir estão disponíveis:

o Copiar arquivos JAR da biblioteca para a pasta Novas bibliotecas. Utilize essa opção se a biblioteca não estiver na pasta que foi selecionada e se você desejar colocar os arquivos JAR aí.

o Utilizar caminho relativo para arquivos JAR da biblioteca. Utilize essa opção se a biblioteca não estiver na pasta de bibliotecas e for necessário acessar a biblioteca em sua localização existente utilizando um caminho relativo. Uma entrada com uma referência relativa é adicionada para a biblioteca no arquivo nblibraries.properties da pasta de bibliotecas.

o Utilizar o caminho absoluto para arquivos JAR da biblioteca. Utilize essa opção se a biblioteca não estiver na pasta de bibliotecas e você precisar acessar a biblioteca em sua localização existente utilizando um caminho absoluto. Uma entrada com uma referência absoluta é adicionada para a biblioteca no arquivo nblibraries.properties da pasta das bibliotecas.

o Utilizar biblioteca existente na pasta de bibliotecas. Utilize essa opção se já houver uma cópia da biblioteca na pasta de bibliotecas e desejar utilizar essa cópia da biblioteca.

6. Clique em Terminar para sair do assistente Tornar projeto compartilhável.

7. Clique em OK para sair da caixa de diálogo Propriedades do projeto.

Nota: também é possível utilizar o nó Bibliotecas da caixa de diálogo Propriedades do projeto para alterar a localização da pasta Bibliotecas. Caso você já tenha especificado uma pasta Bibliotecas, clicar em Procurar abre um seletor de arquivos em vez do assistente para pasta Nova biblioteca.

Tornando o Javadoc disponível no IDE

Page 26: NetBeans 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 a 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.

Habilitando o Java Web Start para o aplicativo

É possível configurar seu aplicativo para ser executado através do Java Web Start no IDE. Para isso, utilize a categoria Java Web Start na janela Propriedades do projeto. Para obter informações detalhadas sobre como habilitar o Java Web Start, consulte o tutorial Habilitando o Java Web Start no NetBeans IDE.

Para configurar o Java Web Start para o aplicativo:

1. clique com o botão direito do mouse no nó do projeto e escolha Propriedades.2. Na caixa de diálogo Propriedades do projeto, selecione o nó Aplicativo > Web Start.

3. Marque a caixa de verificação Habilitar Enable Web Start e configure as definições do Java Web Start como explicado em Habilitando o Java Web Start no NetBeans IDE.

 

Construindo aplicativos

Esta seção explica como construir os projetos padrão no IDE, como efetuar personalizações básicas para o processo de construção e como tratar os erros de compilação.

Construindo projetos, pacotes e arquivos

A compilação no IDE é simples. Assumindo que seu classpath de compilação do projeto está corretamente definido, será necessário somente selecionar o projeto ou o arquivo que deseja compilar e escolher o comando Construir ou Compilar apropriado no menu Executar. O IDE então compila os arquivos.

Se o recurso Compilar ao salvar estiver habilitado para um projeto Java (ou o recurso Implantar ao salvar está habilitado para um projeto Java WEB ou corporativo), o IDE compila automaticamente os arquivos quando estes são salvos. Consulte Compilar ao salvar abaixo, para mais informações.

Para construir seu aplicativo para deployment:

escolha Executar > Limpar e construir o projeto.

Page 27: NetBeans IDE

Todos os arquivos previamente compilados e as saídas distribuíveis como arquivos JAR são excluídos. Então os arquivos são recompilados e novas saídas são produzidas. Uma pasta construir é criada para armazenar as classes compiladas. Um dist é gerado para conter saídas distribuíveis como arquivos JAR e documentação Javadoc. É possível ver as saídas construídas ao abrir a janela Arquivos.

Sempre que comandos de compilação são invocados, o IDE exibe a saída incluindo quaisquer erros de compilação encontrados na janela Saída, como descrito em Corrigindo erros de compilação abaixo.

Compilar ao salvar

O recurso Compilar ao salvar do IDE permite economizar tempo quando você estiver executando e depurando projetos no IDE. Quando o recurso Compilar ao salvar estiver habilitado para um projeto, os arquivos são compilados ao serem salvos. Os arquivos compilados são armazenados em um cache que o IDE utiliza quando o projeto no IDE é executado, testado, depurado e perfilado. Isso permite testar e depurar o aplicativo sem ter que esperar que o aplicativo seja construído primeiro.

Quando habilitado, o recurso Compilar ao salvar tem os seguintes efeitos:

o IDE compila seus arquivos quando estes são salvos para que seu projeto sempre esteja pronto para ser executado ou depurado no IDE.

O comando Construir é desabilitado. É necessário desabilitar o recursos Salvar ao compilar se você quiser reconstruir o arquivo JAR sem ter que utilizar o comando Limpar e construir.

O script do Ant do projeto não é utilizado quando os comandos Executar, Depurar, Perfilar ou Testar são utilizados. Se o script de construção foi personalizado para quaisquer destes comandos, estas personalizações serão desconsideradas.

O arquivo JAR que é construído a partir do projeto não é mantido atualizado quando você salva alterações em seus arquivos. Se desejar construir ou reconstruir o arquivo JAR, é preciso utilizar o comando Limpar e construir. O comando Limpar e construir sempre utiliza o script do Ant de seu projeto, mesmo se Compilar ao salvar está habilitado ou não.

Compilar ao salvar é habilitado por padrão para novos projetos que você cria. Para projetos existentes, Compilar ao salvar é desabilitado.

Para habilitar ou desabilitar Compilar ao salvar para um projeto Java:

1. clique com o botão direito do mouse no nó do projeto e escolha Propriedades.2. Selecione o nó Compilando e defina a propriedade Compilar ao salvar.

De forma similar, o IDE tem um recurso Implantar ao salvar para os aplicativos Java Web e corporativo. Quando o recurso Implantar ao salvar é habilitado para um projeto, e um projeto foi implantado através do IDE, os arquivos alterados são reimplantados imediatamente no servidor. Para que Implantar ao salvar funcione no GlassFish V2, a instância Glassfish precisa ter a opção Deployment de diretório habilitado selecionado.

Para habilitar ou desabilitar Implantar ao salvar para um projeto Java Web ou corporativo:

1. clique com o botão direito do mouse no nó do projeto e escolha Propriedades.2. Selecione o nó Executar e defina a propriedade Implantar ao salvar.

Para habilitar deployment do diretório Glassfish V2:

1. escolha Ferramentas > Servidores.2. Selecione o servidor.

3. Selecione a aba Opções.

Page 28: NetBeans IDE

4. Selecione opção Deployment de diretório habilitado.

Corrigindo erros de compilação

O IDE exibe mensagens de saída e quaisquer erros de compilação na janela Saída. Essa janela com múltiplas abas é exibida automaticamente quando você encontra erros de compilação, depura o programa, gera documentação Javadoc, e assim por diante. Também é possível abrir manualmente essa janela escolhendo Janela > Saída (Ctrl-4).

Além disso, os erros de compilação são mostrados na janela Tarefas e marcados no Editor de código-fonte.

Uma função importante da janela Saída é notificar erros encontrados enquanto compila o programa. A mensagem de erro é exibida em texto sublinhado azul e está vinculada à linha no código-fonte que causou o erro, como ilustrado na imagem abaixo. A janela Saída também fornece links para erros encontrados ao executar scripts de construção do Ant. Sempre que você clica em um link de erro na janela Saída, o Editor do código-fonte salta automaticamente para a linha que contém o erro. Também é possível utilizar os atalhos do teclado F12 e Shift-F12 para mover para o erro seguinte ou anterior no arquivo.

Cada ação realizada por um script Ant, como compilar, executar e depurar arquivos, envia a saída para a mesma aba da janela Saída. Se for necessário salvar as mensagens exibidas na janela Saída, é possível copiar e colar as mensagens em um arquivo separado. Também é possível definir que o Ant imprima a saída do comando para cada novo destino em uma nova aba da janela Saída ao escolher Ferramentas > Opções, selecionando a categoria Miscelâneos, clicando na aba Ant e desmarcando a caixa de verificação para Reutilizar abas de saída da propriedade Processos concluídos.

Filtrando arquivos de saída

Ao criar um arquivo JAR ou WAR, normalmente é desejado incluir apenas os arquivos .class compilados e quaisquer outros arquivos de recursos localizados no diretório de código-fonte, como pacotes de recursos ou documentos XML. O filtro padrão faz isso ao excluir todos os arquivos .java, .nbattrs e .form de seu arquivo de saída.

É possível criar filtros adicionais utilizando expressões regulares para controlar os arquivos de saída. Para especificar quais arquivos devem ser excluídos, clique com o botão direito do mouse em seu projeto na janela Projetos e escolha Propriedades para abrir a caixa de diálogo Propriedades do projeto. No painel esquerdo clique em Empacotamento. No painel direito, insira expressões regulares na caixa de texto para especificar os arquivos a serem excluídos ao empacotar os arquivos JAR ou WAR. Além das expressões padrão, aqui estão algumas expressões regulares adicionais que podem ser utilizadas:

Expressão regular Descrição\.html$ Exclui todos os arquivos HTML

Page 29: NetBeans IDE

\.java$ Exclui todos os arquivos Java(\.html$)|(\.java$) Exclui todos os arquivos HTML e Java(Key)|(\.gif$) Exclui todos os arquivos GIF e quaisquer arquivos com Key em seu nome

Para obter um guia para a sintaxe de expressões regulares consulte jakarta.apache.org.

Executando aplicativos

Esta seção mostra como executar projetos no IDE e como configurar a classe principal do projeto, os argumentos de tempo de execução, os argumentos VM e o diretório de trabalho.

Executando projetos e arquivos

Para projetos Java, você normalmente define o projeto que contém a classe principal do programa como o projeto principal. Para projetos Web, o projeto principal é o projeto que foi implantado primeiro. Para executar um projeto, pacote ou arquivo, escolha um dos seguintes:

no menu principal, escolha Executar > Executar projeto principal (F6) para executar o projeto principal. Alternativamente, é possível utilizar o botão Executar o projeto principal na barra de ferramentas.

Na janela Projetos, clique com o botão direito do mouse no projeto e escolha Executar o projeto para executar um projeto. Observe que para projetos Java, o projeto precisa ter uma classe principal.

Na janela Projetos, clique com o botão direito do mouse no arquivo e escolha Executar o arquivo (F6) para executar um arquivo. Alternativamente, escolha Executar > Executar o arquivo > Executar nome do arquivo (Shift+F6) no menu principal para executar uma classe executável.

Ao executar o projeto, o IDE exibe quaisquer erros de compilação e a saída na janela Saída. Para saber mais, consulte Corrigindo erros de compilação.

Nota: se Compilar ao salvar estiver habilitado para um projeto, o comando Executar o projeto opera em arquivos de classe que foram criados quando estes arquivos foram salvos. O script do Ant não é utilizado. Se etapas personalizadas foram definidas no script de construção, estas etapas não são seguidas. Se desejar que o processo de construção completo ocorra ao utilizar Executar o projeto, Depurar o projeto e Perfilar o projeto, desabilite Compilar ao salvar.

Personalizando as opções de tempo de execução

Como padrão, o IDE não especifica uma classe principal, argumentos do tempo de execução ou argumentos JVM. O classpath do tempo de execução de cada projeto padrão contém as classes compiladas do projeto e tudo o que houver no classpath de compilação do projeto. É possível visualizar o classpath de compilação do projeto ao abrir a caixa de diálogo Propriedades do projeto, selecionar o nó Bibliotecas no painel Categorias e, em seguida, clicar na aba Compilar no painel direito.

Para alterar as opções do tempo de execução, abra a caixa de diálogo Propriedades do projeto ao clicar com o botão direito do mouse no nó do projeto na janela Projetos e escolher Propriedades. Em seguida, selecione o nó Bibliotecas no painel Categorias e clique na aba Executar no painel direito da caixa de diálogo. Note que para acessar as configurações para a classe principal, argumentos do programa, diretório de trabalho para a execução do programa e as opções VM, é preciso selecionar o nó Executar. Na próxima seção, iremos examinar mais de perto sobre como configurar o classpath de tempo de execução.

Page 30: NetBeans IDE

Definindo o classpath de tempo de execução

Para adicionar projetos, bibliotecas, arquivos JAR e pastas para o classpath de tempo de execução, utilize os botões no lado direito da lista Bibliotecas de tempo de execução na caixa de diálogo Propriedades do projeto.

Se o projeto utilizar dinamicamente bibliotecas especiais no tempo de execução através de uma interface indireta ou reflexão (como drivers JDBC ou implementações JAXP), será necessário adicionar essas bibliotecas ao classpath de tempo de execução. Também será necessário ajustar o classpath de tempo de execução se as dependências de tempo de execução entre os projetos não corresponderem às dependências de compilação dos projetos. Por exemplo, imagine que o projeto A é compilado no projeto B e o projeto B é compilado no projeto C, mas o projeto A não é compilado no projeto C. Isso significa que o projeto A possui somente o projeto B no classpath de tempo de execução. Se o projeto A necessitar do projeto B e do projeto C durante a execução, será preciso adicionar o projeto C ao classpath de tempo de execução do projeto A.

Definindo a classe principal e os argumentos de tempo de execução

Para definir a classe principal do projeto, selecione o nó Executar no painel Categorias da caixa de diálogo Propriedades do projeto e digite um nome completamente qualificado no campo Classe principal (por exemplo, org.myCompany.myLib.MyLibClass). A classe principal precisa existir no projeto ou em um dos arquivos ou bibliotecas JAR no classpath de tempo de execução do projeto. Após isso, digite quaisquer argumentos de tempo de execução necessários no campo Argumento.

Se você utiliza o botão Procurar para escolher a classe principal do projeto, o seletor de arquivos só mostrará classes no diretório de código-fonte do projeto. Se desejar especificar uma classe em uma das bibliotecas no classpath, precisará digitar o nome totalmente qualificado da classe no campo Classe principal.

Definindo os argumentos JVM

Page 31: NetBeans IDE

É possível especificar os argumentos JVM para o projeto na caixa de diálogo Propriedades do projeto. Abra a caixa de diálogo Propriedades do projeto, clique em Executar no painel Categorias e, em seguida, digite uma lista de argumentos JVM separada por espaço no campo Opções VM.

É possível definir as propriedades do sistema digitando o seguinte no campo Opções da VM:

-Dname=value

Personalizando o script de construção

Em projetos padrão o IDE gera o script de construção com base nas opções inseridas no assistente Novo projeto e na caixa de diálogo Propriedades do projeto. É possível definir todas as opções básicas de compilação e tempo de execução na caixa de diálogo Propriedades do projeto do projeto e o IDE atualiza automaticamente o script do Ant do projeto. Se você possuir requisitos adicionais para o processo de construção, que não podem ser manipulados na caixa de diálogo Propriedades do projeto, poderá modificar diretamente o script de construção.

O script principal do Ant para projetos padrão é o build.xml. O IDE chama os destinos em build.xml sempre que os comandos do IDE são executados. Esse arquivo possui uma instrução de importação que importa o nbproject/build-impl.xml, que contém destinos de construção que são gerados pelo IDE. No build.xml, é possível sobrepor qualquer destino de nbprojetc/build-impl.xml ou gravar novos destinos. Não edite diretamente o nbproject/build-impl.xml, porque aquele arquivo é gerado novamente com base nas alterações feitas na caixa de diálogo Propriedades do projeto.

Além disso, o script de construção utiliza o nbproject/project.properties que pode ser manualmente editado.

Com projetos padrão, é possível personalizar o processo de construção adotando um dos procedimentos a seguir:

inserindo opções básicas, como as configurações do classpath e filtros JAR no assistente Novo projeto quando você cria um projeto ou posteriormente na caixa de diálogo Propriedades do projeto.

Editando propriedades no nbproject/project.properties. Esse arquivo armazena propriedades do Ant com informações importantes sobre seu projeto, como a localização de seu código-fonte e as pastas de saída. É possível substituir as propriedades nesse arquivo. Tenha cuidado ao editar este arquivo. Por exemplo, a pasta de saída é excluída sempre que você limpa seu projeto. Portanto, nunca defina a pasta de saída para o mesmo local da pasta de código-fonte sem primeiro configurar o destino limpo para não excluir a pasta de saída.

Personalizar alvos Ant existentes ou criar novos ao executar quaisquer um dos seguintes:

o adicione instruções a serem processadas antes ou depois de um alvo do Ant ser executado. Cada um dos destinos principais no nbproject/build-impl.xml também possui um destino -pre e -post que você sobrepõe no build.xml. Por exemplo, para que o RMI funcione com projetos regulares, digite o seguinte no build.xml:

o <target name="-post-compile">o <rmic base="${build.classes.dir}" includes="**/Remote*.class"/>

</target>

o Altere as instruções em um destino do Ant. Copie o destino de nbproject/build-impl.xml para o build.xml e faça quaisquer alterações no destino.

o Crie novos destinos no build.xml. Também é possível adicionar o novo destino nas dependências dos destinos existentes do IDE. Substitua o destino existente em build.xml e, em seguida, adicione o novo destino na propriedade depends do destino existente. Por exemplo, a instrução a seguir adiciona o destino new-target nas dependências do destino de execução:

o <target name="new-target">

Page 32: NetBeans IDE

o <!-- target body... -->o </new-target>o  

<target name="run" depends="new-target,myprojname-impl.run"/>

Não é preciso copiar o corpo do destino de execução no build.xml.

A tabela a seguir lista algumas tarefas comuns que você pode considerar útil para redefinir um arquivo JAR:

Para desempenhar essa tarefa

Siga estas etapas

Especifique quais arquivos são adicionados ao arquivo JAR.

Clique com o botão direito do mouse no nó do projeto na janela Projetos e escolha Propriedades. Clique no subnó Empacotamento (em Construção) e configure as definições do filtro e compressão utilizando o campo Excluir do arquivo JAR. Para mais informações, consulte Filtrando os arquivos de saída

Altere o nome e a localização do arquivo JAR.

Na janela Arquivos, clique duas vezes no arquivo nbproject/project.properties do projeto no Editor de código-fonte. Insira o caminho completo para o arquivo JAR na propriedade dist.jar .

Especifique o arquivo manifesto para o arquivo JAR.

Em project.properties, digite o nome do arquivo manifesto na propriedade manifest.file. O nome do arquivo deve ser especificado em relação ao arquivo build.xml do projeto. Note que se você estiver utilizando o modelo de aplicativo Java, o IDE cria um arquivo manifest.

Desabilite a geração de um arquivo JAR para um projeto.

Na janela Arquivos, abra a pasta do projeto e, em seguida, abra build.xml. Substitua o destino jar para ter conteúdo e não dependências. Por exemplo, adicione o seguinte a build.xml: <target name="jar" />

Se você estiver procurando por recursos de aprendizado do Ant, visite http://ant.apache.org/resources.html. Também é possível instalar o manual do Ant no sistema de ajuda do IDE ao utilizar o Gerenciador de plug-in. Escolha Ferramentas > Plug-ins e instale o módulo Documentação do Ant.

Editando e executando scripts do Ant

O IDE reconhece automaticamente os scripts do Ant e os exibe como nós do Ant ( ) em vez de arquivos XML normais. Para acessar um menu suspenso de comandos é possível clicar com o botão direito do mouse nos scripts do Ant na janela Projetos, janela Arquivos ou na janela Favoritos. Também é possível expandir o nó do script do Ant para visualizar uma lista alfabética de subnós representando os alvos do script do Ant. Cada um desses subnós também possuem um menu suspenso de comandos.

Nas janelas Projetos, Arquivos e Favoritos, os subnós do script do Ant são marcados nas seguintes formas:

Ícone SignificadoAlvo enfatizado do Ant. Estes alvos incluem um atributo de descrição, que é exibido como uma dica de ferramenta. Você define o atributo de descrição do alvo no Editor de código-fonte.Alvo normal do Ant. Um alvo sem um atributo de descrição.

Clique duas vezes nos subnós do script do Ant para ir direto para o local do alvo no Editor de código-fonte. Todas as ferramentas normais de pesquisa XML, ferramentas de seleção e atalhos de teclado estão disponíveis para editar scripts do Ant e o IDE fornece o autocompletar de código para todas as tarefas padrão do Ant.

Ao criar um alvo que deseja executar a partir da linha de comando, forneça um atributo de descrição para o alvo. Então, se você se esquecer dos nomes dos alvos ou o que eles fazem, poderá executar o comando -projecthelp <script> do Ant na linha de comando. Com este comando, o Ant lista somente os alvos que tenham um atributo de descrição, junto com suas descrições. Especialmente quando há muitos alvos em seu

Page 33: NetBeans IDE

script de construção do Ant, enfatizar alguns e não enfatizar outros pode ser uma forma útil de distinguir entre os que são muito utilizados e os que são utilizados com menor frequência.

O estilo da fonte do rótulo do subnó nas janelas Projetos, Arquivos e Favoritos indicam o seguinte:

Normal. Um alvo que é definido dentro do script do Ant atual. Itálico. Um alvo que é importado de outro script do Ant.

Acinzentado. Um alvo interno que não pode ser diretamente executado. Os alvos internos possuem nomes começando por '-'.

Negrito. O alvo padrão para o script, caso haja algum. O alvo padrão é declarado como um atributo para o projeto, junto com outros atributos do projeto, como seu nome. Você define o atributo padrão do projeto no Editor de código-fonte.

Os alvos que são importados de outro script mas que são sobrescritos no script de importação não são listados. Somente o alvo sobescrito é listado.

É possível executar alvos em um script do Ant a partir do nó do script do Ant na janela Projetos, Arquivos ou Favoritos. Para fazer isso, clique com o botão direito do mouse no nó do script do Ant e escolha um alvo a partir do submenu Executar alvo. Os alvos são ordenados alfabeticamente. Somente os alvos enfatizados são listados. Escolha Outros alvos para executar um alvo que não foi enfatizado com um atributo de descrição. Os alvos internos são excluídos dessas listas porque eles não podem ser executados independentemente.

Em vez de executar um alvo utilizando o menu suspenso do nó do script do Ant, basta clicar com o botão direito do mouse no nó do alvo e escolher Executar alvo.

Escrevendo tarefas personalizadas do Ant

É possível utilizar tarefas personalizadas do Ant para expandir a funcionalidade fornecida por tarefas embutidas do Ant. As tarefas personalizadas são utilizadas com frequência para definir propriedades, para criar elementos aninhados ou para escrever texto diretamente entre marcadores utilizando o método addText.

Para criar uma tarefa personalizada do Ant no IDE:

1. clique com o botão direito do mouse no pacote onde gostaria de colocar a tarefa e escolha Novo > Outro.

2. Selecione a categoria Outro e o tipo de arquivo da tarefa personalizada do Ant.

3. Conclua o assistente.

Page 34: NetBeans IDE

Quando você cria o arquivo da tarefa personalizada do Ant, o modelo é aberto no Editor de código-fonte. O modelo contém código de amostra para muitas das operações comuns executadas por tarefas do Ant. Após cada seção do código, o modelo também mostra como utilizar a tarefa em um script do Ant.