双击图标如何执行JAVA程序？

我写了一个java程序。 现在我想在没有IDE，Eclipse等的情况下打开我的控制台java应用程序，只需双击桌面上的可执行版本即可。

我已经在Runnable .JAR文件中导出了java项目，但无法打开它。 当我尝试用cmd打开应用程序时。 java -jar ApplicatonName.jar，一切都很好。 但是这个过程太复杂了，而且不是用户友好的。

那么有什么方法可以用JAVA做这样的事情吗？

提前致谢 ：）

Answer 1

根据操作系统创建bat或sh文件，并将java -jar ApplicationName.jar放在该文件中。

您可以双击该文件以启动您的应用程序。

Windows示例：

创建一个文件MyProgram.bat 。 在文本编辑器中打开文件。 添加java -jar MyApplicationName.jar （将MyApplicationName替换为应用程序的名称/ jar的名称）。 保存文件。 双击创建的文件以打开您的程序。

Answer 2

今天早上我遇到了同样的问题，搜索了一下，并根据可用的知识创建了一个静态类。 它解决了Windows的问题，但其他系统的用户应该能够轻松添加必要的内容 – 我只是不知道正确的系统命令（如果有的话）。 我离开了printEnvironmentInfo（）方法以获得帮助。

它能做什么：

它可以为标准Java控制台应用程序启用双击启动，而无需更改操作系统或创建文件。 程序是这样的：

1. 如果您在IDE中，它只会返回。

2. 它只是返回，以防你有一个控制台。

3. 它在新控制台和EXITS中启动当前运行的.jar文件。

如何使用：

1. 创建Java控制台应用程序

2. 创建类文件AutoRunFromConsole并将以下代码粘贴到package语句下，替换所有内容。

3. 作为main方法中的第一个语句之一，执行AutoRunFromConsole.runYourselfInConsole（true）; （如果您希望在应用程序结束后关闭控制台，则为false）。

怎么运行的：

确定正在运行的Java应用程序的.jar文件名，并检查该文件是否实际存在于当前目录中，以及它是否实际上是文件。

如果这不起作用，我们必须在IDE中，因此有一个控制台。 这应该是可靠的，但是有另一种方法：对（重载）方法的不同调用允许您移交main方法的命令行参数。 如果第一个参数是“ide”（Case被忽略。），则该方法只返回。 当使用此其他调用时，如果无法确定可执行文件名（您甚至可以给予回退。），将显示一条消息（参见下文）。

检查System.console（）是否返回null。 如果没有，它只会返回。

确定基于操作系统的命令行字符串（仅适用于WINDOWS，但您只需填写空白）然后使用Runtime.getRuntime（）。exec（）;执行它。 如果尚未支持操作系统，则会显示一个消息窗口，指出该程序需要从控制台运行，包括。 语法。

如果您有改进（特别是其他系统的工作命令行字符串），请告诉我。

 import javax.swing.*; import java.io.File; import java.io.IOException; import java.security.CodeSource; import java.util.Map; import java.util.Properties; /** * Created by Reddit user king_of_the_universe / StackOverflow user Dreamspace President / dreamspace-president.com * 
 * v[(2), 2015-11-13 13:00 UTC] * 
 * One static method call will start a new instance of *THIS* application in the console and will EXIT the current * instance. SO FAR ONLY WORKS ON WINDOWS! Users of other systems need to assist here. The methods are all in place. */ final public class AutoRunFromConsole { final private static String FAILMESSAGE_TITLE = "Please run in console."; final private static String FAILMESSAGE_BODY = "This application must be run in the console (or \"command box\").\n\nIn there, you have to type:\n\njava -jar nameofprogram.jar"; private static void showFailMessageAndExit() { JOptionPane.showMessageDialog(null, FAILMESSAGE_BODY, FAILMESSAGE_TITLE, JOptionPane.INFORMATION_MESSAGE); System.exit(0); } private enum OSType { UNDETERMINED, WINDOWS, LINUX, MACOS } private static OSType getOsType() { // final String osName = System.getProperty("os.name"); // final String osVersion = System.getProperty("os.version"); // final String osArchitecture = System.getProperty("os.arch"); // System.out.println("\n\nOSNAME: " + osName); // System.out.println("\n\nOSVERSION: " + osVersion); // System.out.println("\n\nOSARCHITECTURE: " + osArchitecture); final String osName = System.getProperty("os.name", "").toLowerCase(); if (osName.startsWith("windows")) { return OSType.WINDOWS; } else if (osName.startsWith("linux")) { return OSType.LINUX; } else if (osName.startsWith("mac os") || osName.startsWith("macos") || osName.startsWith("darwin")) { return OSType.MACOS; } return OSType.UNDETERMINED; } /** * Checks if the program is currently running in console, and if not, starts the program from console and EXITS this * instance of the program. Should be (one of) the first calls in your program. * 
 * This is the less safe variant of the method: To check if you're currently in the IDE, it just tries to find the * executable name and if it exists in the current path. This should word perfectly at all times in IntelliJ - I * don't know what values getExecutableName() returns inside Eclipse, but I suspect it will work just as well. * 
 * It's also less safe because you can't give a fallback executable name, but I believe it should do the trick in * all situations. * 
 * If this is used on a system other than Windows, a message box is shown telling the user to start the program from * the console. BECAUSE I DON'T KNOW HOW TO OPEN A CONSOLE ON OTHER SYSTEMS. SEE startExecutableInConsole(); */ public static void runYourselfInConsole(final boolean stayOpenAfterEnd) { runYourselfInConsole(false, stayOpenAfterEnd, null, null); } /** * Checks if the program is currently running in console, and if not, starts the program from console and EXITS this * instance of the program. Should be (one of) the first calls in your program. * 
 * This is the safer variant of the method: The first command line argument GIVEN BY THE IDE'S RUN CONFIGURATION * should be "ide" (Case is ignored.), which this method will use to determine if it's running from the IDE. * 
 * It is also safer because you can give a fallback executable name in case getExecutableName() could not determine * it. * 
 * Ultimately, it is safer because if the executable could not be determined, it shows a message box telling the * user to start the program from the console. * 
 * You will probably never make use of this variant. It's meant to be a solution if all else seems to fail (eg * customer calls and you need a quick fix). * 
 * If this is used on a system other than Windows, a message box is shown telling the user to start the program from * the console. BECAUSE I DON'T KNOW HOW TO OPEN A CONSOLE ON OTHER SYSTEMS. SEE startExecutableInConsole(); * * @param psvmArguments The arguments given to the main method. * @param fallbackExecutableName Can be null. In case getExecutableName() can't determine the proper name, the * fallback is used. */ public static void runYourselfInConsole(final String[] psvmArguments, final String fallbackExecutableName, final boolean stayOpenAfterEnd) { runYourselfInConsole(true, stayOpenAfterEnd, psvmArguments, fallbackExecutableName); } /** * see the other two methods */ private static void runYourselfInConsole(final boolean useSaferApproach, final boolean stayOpenAfterEnd, final String[] psvmArguments, final String fallbackExecutableName) { String executableName = getExecutableName(fallbackExecutableName); if (useSaferApproach) { if (isRunFromIDE(psvmArguments)) { return; } } else { if (executableName == null) { // Running from IDE. return; } } if (isRunningInConsole()) { return; } if (executableName == null) { showFailMessageAndExit(); } startExecutableInConsole(executableName, stayOpenAfterEnd); System.exit(0); } /** * Opens a console window and starts the Java executable there. * 
 * If this is used on a system other than Windows, a message box is shown telling the user to start the program from * the console. BECAUSE I DON'T KNOW HOW TO OPEN A CONSOLE ON OTHER SYSTEMS. * * @param executableName the full file name of the executable (without path) * @param stayOpenAfterEnd If true (and if someone can figure out the necessary parameters for other systems than * Windows), the console will not close once the executable has terminated. This is useful * eg if you want to give some kind of bye bye message because you actually assumed that * people start the program from console manually. */ private static void startExecutableInConsole(final String executableName, final boolean stayOpenAfterEnd) { String launchString = null; switch (getOsType()) { case UNDETERMINED: break; case WINDOWS: if (stayOpenAfterEnd) { launchString = "cmd /c start cmd /k java -jar \"" + executableName+"\""; // No, using /k directly here DOES NOT do the trick. } else { launchString = "cmd /c start java -jar \"" + executableName+"\""; } break; case LINUX: break; case MACOS: // launchString="/usr/bin/open -a Terminal /path/to/the/executable"; break; } if (launchString == null) { showFailMessageAndExit(); } try { Runtime.getRuntime().exec(launchString); } catch (IOException e) { e.printStackTrace(); } } /** * @param args the args as given to PSVM * @return whether the first command line argument was "ide" (ignoring case). Don't forget to change your IDE's run * configuration accordingly. */ private static boolean isRunFromIDE(final String[] args) { return args != null && args.length > 0 && args[0].equalsIgnoreCase("ide"); } /** * @return if System.console() is available. DOES NOT WORK properly from IDE, will return false then even though it * should be true. Use isRunFromIDE or other means additionally. */ private static boolean isRunningInConsole() { return System.console() != null; } /** * @param fallbackExecutableName Can be null. In the very unlikely case this method can't determine the executable, * the fallback will also be checked. But if the fallback also doesn't exist AS A FILE * in the CURRENT path, null will be returned regardless, even if you're sure that * your fallback should be correct. * @return the name of the running jar file, OR NULL if it could not be determined (which should be a certainty * while in IDE, hence can be abused for determining that). */ public static String getExecutableName(final String fallbackExecutableName) { // APPROACH 1 - THE ONE EVERYBODY ON STACKOVERFLOW IS REPEATING String executableNameFromClass = null; final CodeSource codeSource = AutoRunFromConsole.class.getProtectionDomain().getCodeSource(); if (codeSource == null) { System.err.println("UNEXPECTED: Main.class.getProtectionDomain().getCodeSource() returned null"); } else { final String path = codeSource.getLocation().getPath(); if (path == null || path.isEmpty()) { System.err.println("UNEXPECTED: codeSource.getLocation().getPath() returned null or empty"); } else { executableNameFromClass = new File(path).getName(); } } // APPROACH 2 - QUERY SYSTEM PROPERTIES final Properties properties = System.getProperties(); final String executableNameFromJavaClassPathProperty = properties.getProperty("java.class.path"); final String executableNameFromSunJavaCommandProperty = properties.getProperty("sun.java.command"); // System.out.println("\n\nexecutableNameFromClass:\n" + executableNameFromClass); // System.out.println("\n\nexecutableNameFromJavaClassPathProperty:\n" + executableNameFromJavaClassPathProperty); // System.out.println("\n\nexecutableNameFromSunJavaCommandProperty:\n" + executableNameFromSunJavaCommandProperty); // System.out.println("\n\nfallbackExecutableName:\n" + fallbackExecutableName); if (isThisProbablyTheExecutable(executableNameFromClass)) { return executableNameFromClass; } if (isThisProbablyTheExecutable(executableNameFromJavaClassPathProperty)) { return executableNameFromJavaClassPathProperty; } if (isThisProbablyTheExecutable(executableNameFromSunJavaCommandProperty)) { return executableNameFromSunJavaCommandProperty; } if (isThisProbablyTheExecutable(fallbackExecutableName)) { return fallbackExecutableName; } return null; } /** * @param candidateName suspected name of the running java executable * @return if name is not null, ends with ".jar" (Case is ignored.), and points to a FILE existing in the CURRENT * directory. */ private static boolean isThisProbablyTheExecutable(final String candidateName) { if (candidateName == null || !candidateName.toLowerCase().endsWith(".jar")) { return false; } final File file = new File(candidateName); return file.exists() && file.isFile(); } public static void main(final String[] args) { AutoRunFromConsole.runYourselfInConsole(true); printEnvironmentInfo(); } /** * for debugging purposes */ public static void printEnvironmentInfo() { System.out.println("\n\n\n\n-------------------------- System.getProperties() --------------------------"); final Properties properties = System.getProperties(); for (final Map.Entry entry : properties.entrySet()) { System.out.println(entry); } System.out.println("\n\n\n\n----------------------------- System.getenv() ------------------------------"); final Map env = System.getenv(); for (final Map.Entry entry : env.entrySet()) { System.out.println(entry); } System.out.print("\n\n\n\n"); } }