// 
//     Licensed to the Apache Software Foundation (ASF) under one
//     or more contributor license agreements.  See the NOTICE file
//     distributed with this work for additional information
//     regarding copyright ownership.  The ASF licenses this file
//     to you under the Apache License, Version 2.0 (the
//     "License"); you may not use this file except in compliance
//     with the License.  You may obtain a copy of the License at
// 
//       http://www.apache.org/licenses/LICENSE-2.0
// 
//     Unless required by applicable law or agreed to in writing,
//     software distributed under the License is distributed on an
//     "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
//     KIND, either express or implied.  See the License for the
//     specific language governing permissions and limitations
//     under the License.
//

= Desenvolvendo Aplicações Java Gerais
:jbake-type: tutorial
:jbake-tags: tutorials 
:jbake-status: published
:icons: font
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:description: Desenvolvendo Aplicações Java Gerais - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Desenvolvendo Aplicações Java Gerais

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

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

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


image::images/netbeans-stamp-80-74.png[title="O conteúdo desta página se aplica ao NetBeans IDE 6.8, 6.9, 7.4 e 8.0"]


*Para concluir este tutorial, você precisa do software e dos recursos apresentados na tabela a seguir.*

|===
|Software ou Recurso |Versão Necessária 

|link:https://netbeans.org/downloads/index.html[+NetBeans IDE+] |7.4 ou 8.0 

|link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+JDK (Java Development Kit)+] |6, 7 ou 8 
|===


== Configuração do Projeto 

A aplicação criada conterá dois projetos:

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

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

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


=== [[Criando um Projeto de Biblioteca de Classe Java]] 

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

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


. (Opcional) Marque a caixa de seleção Utilizar Pasta Dedicada para Armazenamento de Bibliotecas e especifique o local da pasta de bibliotecas. Consulte link:http://www.oracle.com/pls/topic/lookup?ctx=nb8000&id=NBDAG455[+Compartilhando uma Biblioteca com Outros Usuários+] em _Desenvolvendo Aplicações com o NetBeans IDE_ para obter mais informações sobre essa opção.


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


=== [[Criando um Projeto de Aplicação Java]] 

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


=== [[Configurando o Classpath de Compilação]] 

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

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

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

image::images/addproj.png[]


. Navegue para `_NetBeansProjects_/` e selecione a pasta de projeto `MyLib`. O painel Arquivos JAR do projeto mostrará os arquivos JAR que podem ser adicionados ao projeto. Observe que um arquivo JAR do MyLib está listado, embora ainda não tenha sido construído. Esse arquivo JAR será contruído quando você construir e executar o projeto MyApp.


. Clique em Adicionar Arquivos JAR do Projeto.


. Expanda o nó Bibliotecas. O arquivo JAR do projeto MyLib será adicionado ao classpath do projeto MyApp.


== Criando e Editando o Código-fonte Java 

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


=== Criando um Pacote e um Arquivo de Classe Java

1. Clique com o botão direito do mouse no nó do projeto MyLib e selecione Novo > Classe Java. Digite `LibClass` como nome da nova classe, digite `org.me.mylib` no campo Pacote e clique em Finalizar. `LibClass.java` será aberto no Editor de Código-fonte.
2. Em `LibClass.java`, coloque o cursor na linha após a declaração de classe (`public class LibClass {`.
3. Digite ou cole este código de método: 

[source,java]
----

    public static String acrostic(String[] args) {
        StringBuffer b = new StringBuffer();
        for (int i = 0; i < args.length; i++) {
            if (args[i].length() > i) {
                b.append(args[i].charAt(i));
            } else {
                b.append('?');
            }
        }
        return b.toString();
                }
----


. Se o código colado não estiver formatado corretamente, pressione Alt-Shift-F para reformatar todo o arquivo.


. Pressione Ctrl-S para salvar o arquivo.


=== Editando um Arquivo Java

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

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

[source,java]
----

String result = Li
----

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


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

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


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

`LibClass` deve estar na lista.


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

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


. No método principal, digite um ponto (.) depois de `LibClass`. A caixa para autocompletar código se abrirá novamente.


. Selecione o método `acrostic(String[]args)` e pressione Enter. O IDE preenche o método `acróstico` e mostra os realces do parâmetro `args`.


. Pressione Enter para aceitar `args` como o parâmetro.


. Insira um ponto-e-vírgula (;).

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


[source,java]
----

String result = LibClass.acrostic(args);
----


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


[source,java]
----

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


. Pressione Ctrl-S para salvar o arquivo.

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


== Compilando e Executando a Aplicação 

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

*Observação:* por default, os projetos foram criados com a funcionalidade Compilar ao Salvar ativada, assim, não é necessário compilar seu código antes de executar a aplicação no IDE. Para obter mais informações, consulte link:http://www.oracle.com/pls/topic/lookup?ctx=nb8000&id=NBDAG525[+Compilando um Único Arquivo Java+] em _Desenvolvendo Aplicações com o NetBeans IDE_.


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

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

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

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


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


=== Executando a Aplicação

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

*Para executar a aplicação no IDE:*

1. Clique com o botão direito do mouse no nó do projeto MyApp e escolha Limpar e Construir.
2. Escolha Executar > Executar Projeto (F6).

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


== Testando e Depurando a Aplicação 

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


=== Criando Testes JUnit

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.


. Na caixa de diálogo Criar Testes, clique em OK para executar o comando com as opções default. O IDE criará o pacote `org.me.mylib` e o arquivo `LibClassTest.java` em uma pasta de `teste` separada. É possível localizar esse arquivo expandindo o nó Testar Pacotes e o subnó `org.me.mylib`.


. Em `LibClassTest.java`, delete o corpo do método `public void testAcrostic()`.


. No lugar das linhas deletadas, digite ou cole o seguinte:

[source,java]
----

System.err.println("Running testAcrostic...");
String result = LibClass.acrostic(new String[]
                  {"fnord", "polly", "tropism"});
                assertEquals("Correct value", "foo", result);
----


. Salve o arquivo pressionando Ctrl-S.


=== Executando Testes JUnit

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

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

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


=== Depurando a Aplicação

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

*Para executar a aplicação no depurador:*

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

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

Para obter mais informações, veja link:junit-intro.html[+Escrevendo Testes JUnit no NetBeans IDE+].


== Construindo, Executando e Distribuindo a Aplicação

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


=== Construindo a Aplicação

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

*Observações:* há também um comando Construir, que não deleta os antigos artefatos de construção, mas que está desativado por default. Consulte link:http://www.oracle.com/pls/topic/lookup?ctx=nb8000&id=NBDAG512[+Sobre a Criação de Projetos Java+] em _Desenvolvendo Aplicações com o NetBeans IDE_ para obter mais informações.

*Para construir a aplicação:*

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

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

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

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

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


[source,java]
----

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

(Para saber mais sobre arquivos de manifesto, leia link:http://java.sun.com/docs/books/tutorial/deployment/jar/manifestindex.html[+este capítulo+] no Tutorial de Java.)


=== Executando a Aplicação fora do IDE

*Para executar a aplicação fora do IDE:*

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

[source,java]
----

                java -jar MyApp.jar However we all feel zealous    
----

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


[source,java]
----

Result = Hello
            
----
[.feature]
--
image::images/command-prompt-smaller.png[role="left", link="images/command-prompt.png"]
--


=== Distribuindo a Aplicação para Outros Usuários

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

*Para distribuir a aplicação:*

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


== Outras Tarefas Comuns

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


=== Tornando o Javadoc Disponível no IDE

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

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

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

1. Faça download do código-fonte da documentação API de Javadoc (consulte a página link:http://wiki.netbeans.org/FaqJavaDoc#Adding_the_JDK_Javadoc_to_the_NetBeans_IDE[+FaqJavaDoc+] para obter detalhes adicionais).
2. Selecione Ferramentas > Plataformas Java.
3. Clique na guia Javadoc.
4. 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.
5. Clique em Fechar.


=== Gerando o Javadoc de um Projeto

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

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

1. Selecione o Projeto MyLib.
2. No menu principal do IDE, selecione Executar > Gerar Javadoc para "MyLib". 
O Javadoc gerado é adicionado à pasta `dist` do projeto. Além disso, o IDE abre uma janela do Web browser que exibe o Javadoc.
link:/about/contact_form.html?to=3&subject=Feedback:%20Developing%20General%20Java%20Applications[+Enviar Feedback neste Tutorial+]


== Próximas Etapas

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

* link:javase-deploy.html[+Encapsulando e Implantando Aplicações Java Desktop+]
* link:annotations.html[+Suporte aos Processadores de Anotação no NetBeans IDE+]
* link:debug-multithreaded.html[+Depurando Aplicações Multithread+]
* link:../../trails/java-se.html[+Trilha de Aprendizado do Desenvolvimento Geral em Java+]
* link:../../trails/matisse.html[+Trilha do Aprendizado de Java e JavaFX GUI+]
* link:../../index.html[+Página de Documentação e Suporte do NetBeans IDE+]
* link:http://www.oracle.com/pls/topic/lookup?ctx=nb8000&id=NBDAG366[+Criando Projetos Java+] em _Desenvolvendo Aplicações com o NetBeans IDE_