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

= Encapsulamento e Distribuição de Aplicações Java Desktop
:jbake-type: tutorial
:jbake-tags: tutorials 
:jbake-status: published
:icons: font
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:description: Encapsulamento e Distribuição de Aplicações Java Desktop - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Encapsulamento e Distribuição de Aplicações Java Desktop

Uma pergunta que muitos programadores iniciantes têm é: "Agora que criei minha aplicação no IDE, como faço para que ela funcione a partir da linha de comandos fora do IDE." De forma similar, alguém pode perguntar: "Como distribuo esta aplicação para outros usuários sem precisar dar a eles todo o IDE também?"

As respostas para essas perguntas são relativamente simples, mas não necessariamente óbvias. Este documento trata essas perguntas explicando os fundamentos do uso do IDE para preparar suas aplicações para distribuição e implantação. Além disso, este documento fornece informações que podem ser necessárias para configurar seu sistema (ou que podem ser necessárias para passar para os usuários de suas aplicações). Mostraremos algumas abordagens diferentes para a implantação de uma aplicação para que os usuários possam acessá-la:

* Clicando duas vezes no arquivo compactado JAR da aplicação.
* Chamando a aplicação da linha de comandos.
* Chamando a aplicação de um arquivo de script.
* Usando o Java Web Start.


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

* Criando um Projeto com Códigos-fontes Existentes

 

*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+] |versão 8.0 

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

versão 7 ou 8

 

|link:https://netbeans.org/projects/samples/downloads/download/Samples%252FJava%252FDeploymentTutorial.zip[+Arquivos do código-fonte do Tutorial de Implantação+] |

 

 
|===



== Criando o Arquivo JAR Executável

Esta parte do tutorial mostra como criar uma aplicação distribuível no IDE e, a seguir, executar aquela aplicação de fora do IDE. Encapsularemos a aplicação na forma de um arquivo link:http://download.oracle.com/javase/tutorial/deployment/jar/run.html[+JAR+] executável.

Um arquivo compactado JAR é um arquivo compactado que pode conter vários arquivo e pastas. Arquivos JAR são similares e arquivos zip, mas arquivos JAR podem ter atributos adicionais que são úteis para distribuir aplicações Java. Esses atributos incluem a assinatura digital de arquivos JAR, compactação adicional, compatibilidade entre plataformas etc.

Neste exercício, você criará um projeto IDE e, a seguir, colocar dois arquivos de código-fonte Java pré-escritos dentro do projeto. Em seguida, você compilará as classes e construirá o arquivo JAR executável. Depois disso, você aprenderá a executar o arquivo JAR fora do IDE.

As classes usadas neste tutorial implementam as funcionalidades do utilitário link:http://www.gnu.org/software/grep/[+GNU grep+], que pode ser usado para procurar texto ou padrões de expressões regulares dentro de arquivos texto. O projeto contém versões de linha de comandos e de GUI da aplicação para que você possa ver as diferentes formas de executar a aplicação.


=== Criando um Projeto com Códigos-fontes Existentes

1. Faça download do arquivo link:https://netbeans.org/projects/samples/downloads/download/Samples%252FJava%252FDeploymentTutorial.zip[+DeploymentTutorial.zip+] e extraia seu conteúdo no sistema. 
Esse arquivo compactado zip contém arquivos de código-fonte para a aplicação, além de alguns outros arquivos que serão usados no tutorial.


[start=2]
. No NetBeans IDE, escolha Arquivo > Novo Projeto.


[start=3]
. Na página Selecionar Categoria, selecione Projeto Java com Códigos-fonte Existentes na categoria Java e clique em Próximo.

[start=4]
. Na página Nome e Localização do assistente, digite  ``AnotherGrep``  como o nome do projeto e especifique o local do projeto. 
Clique em Próximo.

A pasta do projeto _não_ precisa estar no mesmo local que os arquivos de código-fonte que você está importando para o projeto.


[start=5]
. Na página Códigos-fonte existentes do assistente, especifique os códigos-fonte que estarão no projeto. 
Clique no botão Adicionar Pasta, à direita do campo Pastas de Pacote de Código-fonte. Navegue até a pasta  ``DeploymentTutorial``  que você acabou de descompactar em seu sistema, expanda a pasta, selecione a pasta  ``src``  e clique em Abrir. A pasta  ``src``  é adicionada ao campo Pastas de Pacote de Código-fonte.

[start=6]
. Clique em Finalizar.

*Observação:* Se, por exemplo, você desejar excluir alguns arquivos de código-fonte da importação para o projeto, clique em Próximo para abrir a última janela Inclusões e Exclusões. Em nosso caso, queremos usar todos os arquivos de código-fonte na pasta  ``src`` , portanto clicamos em Finalizar para concluir o assistente Novo Projeto.

O projeto é aberto no IDE e fica visível na janela Projetos. Você pode explorar o conteúdo do projeto expandindo o nó Pacotes de Código-fonte do projeto onde deverá ver classes chamadas  ``Grep``  e  ``xGrep`` .  ``Grep.java``  é a versão de console da aplicação.  ``xGrep.java``  é a versão de GUI da aplicação e usa os métodos definidos em  ``Grep.java`` .


=== Configurando o Projeto

Há alguns passos de configuração que são necessários:

* Escolher a plataforma Java que será usada para compilar os códigos-fonte.
* Definir a classe principal do projeto. Ao fazer isso, você garante que o arquivo JAR criado ao construir o projeto será executável.


==== Verificando a Plataforma Java

Nosso projeto precisa ser compilado e executado na plataforma Java 7 ou Java 8. Portanto, certifique-se de que o Java 7 ou 8 seja respectivamente usado como a plataforma desse projeto.

1. Clique com o botão direito do mouse no nó do projeto e escolha Propriedades.
2. Na guia Bibliotecas, assegure-se de que a Plataforma Java seja JDK 1.7 (ou JDK 1.8).
3. Na guia Códigos-fonte, selecione JDK 7 (ou JDK 8) no formato de Código-fonte/Binário.
4. Clique em OK para fechar a janela Propriedades.


==== Definindo a Classe Principal

Para que um usuário execute facilmente seu arquivo JAR (clicando duas vezes no arquivo JAR ou digitando  ``java -jar AnotherGrep.jar``  na linha de comandos), uma classe main deve ser especificada dentro do arquivo _manifest_ do JAR. (O manifesto é uma parte padrão do arquivo JAR que contém informações sobre o arquivo JAR que são úteis para o acionador  ``java``  ao executar a aplicação.) A classe principal serve como ponto de entrada a partir da qual o acionador  ``java``  executa sua aplicação.

Quando você constrói um projeto, o IDE constrói o arquivo JAR e inclui um manifesto. Ao definir a classe principal do projeto, você garante que ela seja designada no manifesto.

Para definir a classe principal do projeto:

1. Clique com o botão direito do mouse no nó do projeto e escolha Propriedades.
2. Selecione a categoria Executar e digite  ``anothergrep.xGrep``  no campo Classe Principal.
3. Clique em OK para fechar a caixa de diálogo Propriedades do Projeto.

Quando você construir o projeto posteriormente neste tutorial, o manifesto será gerado e incluirá a seguinte entrada:


[source,java]
----

Main-Class: anothergrep.xGrep
----


=== Construindo o Projeto e Criando o Arquivo JAR

Agora que os códigos-fonte estão prontos e seu projeto está configurado, é hora de construir o projeto.

Para construir o projeto:

* Escolha Executar > Criar Projeto (AnotherGrep).
Alternativamente, clique com o botão direito do mouse no nó do projeto na janela Projetos e escolha Construir.

Ao construir o projeto:

* 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 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/AnotherGrep.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: anothergrep.xGrep
----

(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 e Distribuindo o Arquivo JAR


=== Executando a Aplicação no IDE

Ao desenvolver aplicações no IDE, normalmente você precisará testá-las e refiná-las antes da distribuição. Você pode testar facilmente uma aplicação na qual esteja trabalhando ao executar a aplicação a partir do IDE.

Para executar o projeto  ``AnotherGrep``  no IDE, clique com o botão direito do mouse no nó do projeto na janela Projetos e selecione Executar.

A janela xGrep será aberta. Clique no botão Procurar para selecionar um arquivo no qual pesquisar um padrão de texto. No campo Pesquisar Padrão, digite um texto ou um padrão de expressão regular que deseja localizar e clique em Pesquisar. Os resultados de cada correspondência serão exibidos na área Saída da janela xGrep.

Informações sobre expressões regulares que podem ser usadas nesta aplicação estão disponíveis link:http://www.gnu.org/software/grep/manual/html_node/Regular-Expressions.html#Regular-Expressions[+aqui+] e em muitos outros locais.


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

Depois de finalizar o desenvolvimento da aplicação e antes de distribuí-la, você provavelmente desejará garantir que ele também funciona fora do IDE.

É possível executar a aplicação fora do IDE seguindo estas etapas:

* No gerenciador de arquivos do sistema (por exemplo, na janela Meu Computador em sistemas Windows XP), navegue para  ``_PROJECT_HOME_/dist``  e clique duas vezes no arquivo  ``AnotherGrep.jar`` .

Você saberá se a aplicação foi iniciada com sucesso quando a janela xGrep for aberta.

Se a janela xGrep não for aberta, seu sistema provavelmente não tem a associação de arquivos entre os arquivos JAR e o ambiente de runtime do Java. Consulte <<troubleshooting,Associações de Arquivos JAR>> abaixo.


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

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

* Envie o arquivo JAR da aplicação para as pessoas que o usarão. Os usuários de sua aplicação deverão conseguir executá-la clicando duas vezes no arquivo JAR. Se isso não funcionar para eles, mostre-lhes as informações na seção <<troubleshooting,Diagnóstico e Solução de Problemas de Associações de Arquivos JAR>> abaixo.

*Observação*: se sua aplicação depende de bibliotecas adicionais além das incluídas no JDK, será preciso inclui-las em sua distribuição (não é o caso em nosso exemplo). Os caminhos relativos para essas bibliotecas são adicionados na entrada  ``classpath``  do arquivo manifesto do JAR durante o desenvolvimento da aplicação no IDE. Se essas bibliotecas adicionais não forem encontradas no classpath especificado (ou seja, caminho relativo) na execução, a aplicação não será iniciada. 
Crie um arquivo compactado zip que contenha o arquivo JAR da aplicação e a biblioteca e forneça esse arquivo zip para os usuários. Instrua os usuários a descompactar o arquivo zip, certificando-se de que o arquivo JAR e os arquivos JAR das bibliotecas estejam na mesma pasta. Execute o arquivo JAR da aplicação.


== Iniciando sua Aplicação Java

O objetivo deste exercício é mostrar algumas formas de iniciar a aplicação a partir da linha de comandos.

Este exercício mostra como é possível iniciar uma aplicação Java das seguintes formas:

* Executando o comando  ``java``  a partir da linha de comandos.
* Usando um script para chamar uma classe no arquivo JAR.


=== Iniciando Aplicações a partir da Linha de Comando

Você pode iniciar uma aplicação a partir da linha de comandos usando o comando  ``java`` . Se desejar executar um arquivo JAR executável, use a opção  ``-jar``  do comando.

Por exemplo, para executar a aplicação AnotherGrep, execute as seguintes etapas:

1. Abra uma janela de terminal. Em sistemas Microsoft Windows, isso é feito selecionando Iniciar > Executar, digitando  ``cmd``  no campo Abrir e clicando em OK.
2. Mude o diretório para a pasta  ``_PROJECT_HOME_/dist``  (usando o comando  ``cd`` ).
3. Digite a seguinte linha para executar a classe principal da aplicação:

[source,java]
----

java -jar AnotherGrep.jar
----

Se você seguir essas etapas e a aplicação não for executada, provavelmente será preciso executar um dos seguintes procedimentos:

* Inclua o caminho completo para o binário  ``java``  na terceira etapa do procedimento. Por exemplo, digite algo como o seguinte, dependendo de onde seu JDK ou JRE está localizado:

[source,java]
----

C:\Program Files\Java\jdk1.7.0_51\bin\java -jar AnotherGrep.jar
----
* Adicione os binários Java à sua variável de ambiente PATH pra que não seja preciso especificar o caminho para o binário  ``java``  na linha de comandos. Consulte <<path,Definindo as Variáveis do Ambiente PATH>>.


=== Iniciando Aplicações de um Script

Se a aplicação que você deseja distribuir for uma aplicação de console, pode ser mais conveniente iniciar a aplicação de um script, principalmente se a aplicação usar argumentos longos e complexos para a execução. Nesta seção, você usará a versão de console do programa Grep, na qual é necessário passar os argumentos (padrão de pesquisa e lista de arquivos) para o arquivo JAR, que serão chamados em nosso script. Para reduzir a digitação na linha de comandos, você usará um script simples, adequado para executar a aplicação de teste.

Primeiro, é preciso alterar a classe principal na aplicação para ver a versão de console da classe e recompilar o arquivo JAR:

1. Na janela Projetos do IDE, clique com o botão direito do mouse no nó do projeto ( ``AnotherGrep`` ) e selecione Propriedades.
2. Selecione o nó Executar e altere a propriedade Classe principal para  ``anothergrep.Grep``  (de  ``anothergrep.xGrep`` ). Clique em OK para fechar a janela Propriedades do Projeto.
3. Clique com o botão direito do mouse no nó do projeto novamente e escolha Limpar e Construir Projeto.

Depois de concluir essas etapas, o arquivo JAR é recompilado e o atributo  ``Main-Class``  do manifesto do arquivo JAR é alterado para apontar para  ``anothergrep.Grep`` .


==== Script link:http://www.gnu.org/software/bash/bash.html[+BASH+] -- para máquinas UNIX e Linux

Dentro da pasta do sistema onde o conteúdo do arquivo link:https://netbeans.org/projects/samples/downloads/download/Samples%252FJava%252FDeploymentTutorial.zip[+DeploymentTutorial.zip+] foi descompactado, há um script bash  ``grep.sh`` . Observe:


[source,java]
----

#!/bin/bash
                    java -jar dist/AnotherGrep.jar $@
----

A primeira linha declara qual o shell que deverá ser usado para interpretar isso. A segunda linha executa seu arquivo JAR, criado pelo IDE dentro da pasta  ``_PROJECT_HOME_/dist`` .  ``$@``  somente copia todos os argumentos fornecidos, colocando-os entre aspas.

Esse script presume que os binários Java sejam parte de sua variável de ambiente PATH. Se o script não funcionar, consulte <<path,Definindo as Variáveis do Ambiente PATH>>.

Mais informações sobre scripts bash podem ser encontradas link:http://www.gnu.org/software/bash/manual/bashref.html[+aqui+].


==== Script .bat para máquinas Windows

Em sistemas Microsoft Windows, só é possível especificar nove argumentos de cada vez para um arquivo batch. Se houver mais de nove argumentos, será preciso executar o arquivo JAR mais de uma vez.

Um script que trate isso pode ser similar a:


[source,java]
----

                @echo off
                set jarpath="dist/AnotherGrep.jar"
                set pattern="%1"
                shift
                :loop
                  if "%1" == "" goto :allprocessed
                  set files=%1 %2 %3 %4 %5 %6 %7 %8 %9
                  java -jar %jarpath% %pattern% %files%
                  for %%i in (0 1 2 3 4 5 6 7 8) do shift
                goto :loop

                :allprocessed
                    
----

Este script está incluído como  ``grep.bat``  dentro da pasta de seu sistema, onde você extraiu o conteúdo do arquivo link:https://netbeans.org/projects/samples/downloads/download/Samples%252FJava%252FDeploymentTutorial.zip[+DeploymentTutorial.zip+], portanto, é possível testá-lo.

Os nove argumentos são representados dentro do arquivo batch por  ``%<ARG_NUMBER>`` , em que  ``<ARG_NUMBER>``  deve estar dentro do intervalo  ``<0-9>`` .  ``%0``  é reservado para o nome do script.

Você pode observar que somente nove argumentos são passados para o programa de cada vez (em um loop). A instrução  ``for``  desloca os argumentos em nove para preparar para o próximo loop. Quando um argumento vazio de arquivo é detectado pela instrução  ``if``  (não há mais arquivos a processar), o loop é encerrado.

Mais informações sobre scripts batch podem ser encontradas link:http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/batch.mspx[+nesta página+].


== Encapsulando a Aplicação para Java Web Start

O Java Web Start é uma tecnologia que é utilizada para executar aplicações Java de um Web browser com apenas um clique. Para obter informações detalhadas sobre como encapsular aplicações para implantação com Java Web Start, consulte link:../../73/java/javase-jws.html[+Ativando o Java Web Start no NetBeans IDE+]. Aqui, fornecemos apenas passos rápidos que devem ser seguidos para que sua aplicação possa ser implantada usando Java Web Start.

1. Clique com o botão direito do mouse no nó do projeto na janela Projetos e escolha Propriedades.
2. Na guia Web Start da janela Propriedades do Projeto, marque a caixa de seleção Ativar o Web Start.
3. Escolha Execução Local na lista drop-down Código-base (já que primeiro executaremos a aplicação localmente).
4. Clique em Personalizar para assinar a aplicação especificando os detalhes na caixa de diálogo Assinatura.

*Observação:* a partir do Java SE 7 Atualização 21 de abril de 2013, é recomendável que todos os Applets Java e Aplicações Web Start sejam assinados com um certificado confiável. Consulte link:http://www.oracle.com/technetwork/java/javase/tech/java-code-signing-1915323.html[+Applet Java e Web Start - Assinatura de Código+] para obter mais informações.


[start=5]
. Deixe todas as outras definições com seus valores default e clique em OK.

[start=6]
. Clique com o botão direito do mouse no nó do projeto e escolha Limpar e Construir Projeto. 
Este comando do IDE deleta todos os arquivos anteriormente compilados e as saídas geradas, recompila sua aplicação e constrói o projeto com as novas definições.

[start=7]
. Fora do IDE, abra a pasta  ``_PROJECT_HOME_/dist``  e abra o arquivo  ``launch.html``  no browser.
A página HTML de teste com o botão Iniciar é aberta.

[start=8]
. Clique no botão Iniciar para abrir a aplicação. 
Você pode ver que o Java foi carregado e a aplicação é iniciada.

*Observação:* alguns browsers redirecionam primeiro para a página de download do Java.


== Dicas de Diagnóstico e Solução de Problemas


=== Especificando Associações de Arquivo JAR

Na maioria dos sistemas, é possível executar um arquivo JAR executável simplesmente clicando duas vezes nele. Se nada acontecer ao clicar duas vezes no arquivo JAR, pode ser por um dos dois motivos a seguir:

* O tipo de arquivo JAR provavelmente não está associado com um Ambiente de Runtime Java (JRE) naquele sistema.

Se o tipo de arquivo JAR estiver associado com um JRE, o ícone que representa o arquivo deverá incluir um logo do Java.

* O tipo de arquivo JAR está associado com o JRE, mas a opção  ``-jar``  não está incluída no comando que é passado para o JRE quando você clica duas vezes no ícone.

*Observação:* algumas vezes, associações de arquivos JAR são trocadas por softwares que você instala, como os softwares que tratam arquivos zip.

A forma de associar o tipo de arquivo JAR com o acionador  ``java``  depende do sistema operacional.

*Observação:* certifique-se de que haja uma versão do JRE instalada em seu sistema. Você deverá usar a versão 1.4.2 ou posterior. Não é possível iniciar uma aplicação Java se o Java não estiver instalado. (Se você tiver o JDK instalado, também terá o JRE. No entanto, se você estiver distribuindo o programa para uma pessoa que não seja programadora, não necessariamente ela terá o JRE ou o JDK.)

* No Windows XP, você pode verificar as versões instaladas do Java selecionando Iniciar > Painel de Controle > Adicionar ou Remover Software (você verá, por exemplo, Java(TM) 7 Update 51).
* No Windows Vista ou 7, você pode verificar as versões instaladas do Java escolhendo Iniciar > Painel de Controle > Programas e Componentes (você verá, por exemplo, Java(TM) 7 Update 51).

Se não houver o Java no sistema, você poderá obter o JRE no link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+site de download do Java SE+].

Se tiver Java instaladas no seu sistema, mas o arquivo de associação não estiver funcionando, continue com as etapas para adicionar o arquivo jar associação no Microsoft Windows:

1. Clique em Iniciar > Painel de Controle.
2. (Aplicável somente para Windows Vista.) Clique em Painel de Controle > Programas.
3. Para Windows xp, clique duas vezes em Opções de Pasta e selecione a guia Tipos de Arquivo.
para Windows Vista ou 7, clique em Programas Default e selecione Associar um tipo de arquivo ou protocolo com um programa.

[start=4]
. Na lista Tipos de Arquivos Registrados, selecione Arquivo JAR.

[start=5]
. (no Windows XP, na seção Detalhes da caixa de diálogo), clique em Alterar Programa.

[start=6]
. Na caixa de diálogo Abrir com, selecione Java Platform SE Binary.

[start=7]
. Clique em OK para sair da caixa de diálogo Abrir com.

[start=8]
. Clique em Fechar para sair da caixa de diálogo Opções de Pasta (no Windows xp) ou o tipo de arquivo ou associar um protocolo com uma caixa de diálogo de programa específico (no Windows 7).

*Observação:* se os arquivos JAR estiverem associados com o Java Platform SE Binary em seu sistema, mas ao clicar duas vezes ainda não foi executado o arquivo JAR, poderá ser necessário especificar a opção  ``-jar``  na associação do arquivo.

Para especificar a opção  ``-jar``  na associação do arquivo no Microsoft Windows XP:

1. Clique em Iniciar > Painel de Controle.
2. Para Windows xp, clique duas vezes em Opções de Pasta e selecione a guia Tipos de Arquivo.
3. Na lista Tipos de Arquivos Registrados, selecione Arquivo JAR.
4. Na seção Detalhes da caixa de diálogo, clique em Avançado.
5. Na caixa de diálogo Editar Tipo de Arquivo, clique em Editar.
6. No campo de texto Aplicação Usada para Executar Ação, adicione o seguinte no final do caminho para o JRE:

[source,java]
----

 -jar "%1" %*
----
Depois disso, o campo deverá conter texto similar ao seguinte:

[source,java]
----

"C:\Program Files\Java\jre1.7.0_51\bin\javaw.exe" -jar "%1" %*
----

[start=7]
. Clique em OK para sair da caixa de diálogo Ação de Edição para o Tipo.

[start=8]
. Clique em OK para sair da caixa de diálogo Editar Tipo de Arquivo.

[start=9]
. Clique em Fechar para sair da caixa de diálogo Opções de Pasta.

*Observação:* iniciando com Windows Vista as associações do arquivo avançadas podem ser definidas por regedit. Consulte o artigo link:http://technet.microsoft.com/en-us/magazine/ee914604.aspx[+O que Aconteceu com a Caixa de Diálogo Tipos de Artigo?+] para obter detalhes.

Para sistemas UNIX e Linux, o procedimento para alterar as associações de arquivos depende do ambiente de área de trabalho (como GNOME ou KDE) que você está usando. Veja as definições de preferência em seu ambiente de área de trabalho ou consulte a documentação do ambiente.


=== Definindo a Variável do Ambiente PATH

Se você não puder executar uma classe Java ou um arquivo JAR em seu sistema sem apontar para o local do JDK ou do JRE, poderá ser necessário modificar o valor da variável  ``PATH``  do sistema.

Se você estiver executando um sistema Microsoft Windows, o procedimento para definir a variável PATH depende da versão do Windows em uso.

A seguir, estão as etapas para definir a variável  ``PATH``  em um sistema Windows XP:

1. Clique em Iniciar > Painel de controle e clique duas vezes em Sistema.
2. Na caixa de diálogo Propriedades do Sistema, clique na guia Avançado.
3. Clique na guia Variáveis de Ambiente.
4. Na lista de variáveis do usuário, selecione  ``PATH``  e clique em Editar.
5. Adicione o local do JRE no final da lista de caminhos. Os locais nessa lista são separados por ponto e vírgula (;). 
Por exemplo, se o seu JRE está localizado em `c:\arquivos de programa\java\jdk1.7.0_51`, você adicionaria a seguinte ao final da variável PATH:

[source,java]
----

C:\Program Files\Java\jdk1.7.0_51\bin
----

[start=6]
. Clique em OK para sair da caixa de diálogo Variáveis de Ambiente, e clique em OK para sair da caixa de diálogo Propriedades do Sistema.

Se você estiver executando um sistema UNIX ou Linux, as instruções para modificar a variável PATH depende do programa shell que está em uso. Consulte a documentação do shell que está em uso para obter mais informações.

link:/about/contact_form.html?to=3&subject=Feedback:%20Packaging%20and%20Distributing%20Java%20Desktop%20Applications[+Enviar Feedback neste Tutorial+]



== Próximas Etapas

Para obter mais informações sobre como trabalhar com o NetBeans IDE, consulte a página link:https://netbeans.org/kb[+Suporte e Documentação+] no site do NetBeans.

Para saber mais sobre o fluxo de trabalho do IDE para o desenvolvimento de aplicações Java, incluindo o gerenciamento de classpath, consulte link:javase-intro.html[+Desenvolvendo Aplicações Java Gerais+].

Para obter informações sobre como criar funcionalidades no NetBeans IDE, consulte link:http://www.oracle.com/pls/topic/lookup?ctx=nb8000&id=NBDAG510[+Criando Projetos Java+] em _Desenvolvendo Aplicações com o NetBeans IDE_.

