Eu prefiro a primeira versão para iniciar um aplicativo java apenas porque tem menos armadilhas ("bem-vindo ao inferno do classpath"). O segundo requer um arquivo jar executável e o classpath para esse aplicativo deve ser definido dentro do manifesto do jar (todas as outras declarações de classpath serão silenciosamente ignoradas ...). Assim, com a segunda versão, você teria que olhar para o jar, ler o manifesto e tentar descobrir se as entradas do classpath são válidas de onde o jar está armazenado ... Isso é evitável.
Não espero nenhuma vantagem ou desvantagem de desempenho para nenhuma das versões. É apenas dizer ao jvm qual classe usar para o thread principal e onde pode encontrar as bibliotecas.
Com o
-cp
argumento, você fornece o caminho de classe, ou seja, caminho (s) para classes ou bibliotecas adicionais que seu programa pode exigir ao ser compilado ou executado. Com-jar
você especifica o arquivo JAR executável que deseja executar.Você não pode especificar os dois. Se você tentar correr
java -cp folder/myexternallibrary.jar -jar myprogram.jar
, não funcionará de verdade. O caminho de classe para esse JAR deve ser especificado em seu Manifesto, não como um-cp
argumento.Você pode encontrar mais sobre isso aqui e aqui .
PS:
-cp
e-classpath
são sinônimos.fonte
-cp
e-classpath
, então não, não há diferença.-jar
você especifica qual JAR executável deseja executar. Com-cp
você especifica o (s) caminho (s) para classes / bibliotecas adicionais que seu programa pode exigir. Os 2 têm finalidades muito diferentes.java -jar PATH -cp PATH2
Ao usar,
java -cp
é necessário fornecer um nome de classe principal totalmente qualificado, por exemplojava -cp com.mycompany.MyMain
Ao usar
java -jar myjar.jar
seu arquivo jar deve fornecer as informações sobre a classe principal via manifest.mf contido no arquivo jar na pastaMETA-INF
:Main-Class: com.mycompany.MyMain
fonte
java -cp CLASSPATH é necessário se você deseja especificar todo o código no classpath. Isso é útil para depurar código.
O formato executável jarred:
java -jar JarFile
pode ser usado se você deseja iniciar o aplicativo com um único comando curto. Você pode especificar arquivos jar dependentes adicionais em seu MANIFESTO usando jars separados por espaço em uma entrada Class-Path, por exemplo:Ambos são comparáveis em termos de desempenho.
fonte
Como já foi dito, o -cp serve apenas para dizer ao jvm na linha de comando qual classe usar para o thread principal e onde ele pode encontrar as bibliotecas (definir classpath). Em -jar, ele espera que o caminho da classe e a classe principal sejam definidos no manifesto do arquivo jar. Portanto, outro é para definir coisas na linha de comando, enquanto outro é encontrá-los dentro do manifesto jar. Não há diferença no desempenho. Você não pode usá-los ao mesmo tempo, -jar substituirá o -cp.
Embora mesmo se você usar -cp, ele ainda verificará o arquivo de manifesto. Portanto, você pode definir alguns dos caminhos de classe no manifesto e alguns na linha de comando. Isso é particularmente útil quando você tem uma dependência de algum jar de terceiros, que você pode não fornecer com sua compilação ou não deseja fornecer (esperando que já seja encontrado no sistema onde será instalado, por exemplo). Portanto, você pode usá-lo para fornecer jars externos. Sua localização pode variar entre os sistemas ou pode até ter uma versão diferente em um sistema diferente (mas com as mesmas interfaces). Desta forma, você pode construir o aplicativo com outra versão e adicionar a dependência real de terceiros ao caminho de classe na linha de comando ao executá-lo em sistemas diferentes.
fonte
Não haverá diferença em termos de desempenho. Usando java - cp, podemos especificar as classes necessárias e jar's no classpath para executar um arquivo de classe java.
Se for um arquivo jar executável. Quando o comando java -jar é usado, o jvm encontra a classe necessária para executar a partir do arquivo /META-INF/MANIFEST.MF dentro do arquivo jar.
fonte