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

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

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

那么，有没有任何可能的方法可以用JAVA来做这样的事情呢

---

提前感谢：）

根据操作系统创建一个

bat

或

sh

文件，并将

java-jar ApplicationName.jar

放在该文件中

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

Windows的示例：

---

创建一个文件

MyProgram.bat

。在文本编辑器中打开该文件。添加

java-jar MyApplicationName.jar

（将MyApplicationName替换为应用程序的名称/jar的名称）。保存文件。双击创建的文件打开您的程序。

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

它的作用：

它支持标准Java控制台应用程序的双击启动，而无需更改操作系统或创建文件。程序如下：

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

它只是在你有控制台的情况下返回

它在新控制台中启动当前正在运行的.jar文件并退出

如何使用：

创建Java控制台应用程序

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

作为main方法中的第一条语句之一，请执行AutoRunFromConsole.runyourselfincole（true）；（如果希望在应用程序结束后关闭控制台，则为false）

工作原理：

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

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

检查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
 * <p>
 * v[(2), 2015-11-13 13:00 UTC]
 * <p>
 * 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.
     * <p>
     * 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.
     * <p>
     * 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.
     * <p>
     * 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.
     * <p>
     * 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.
     * <p>
     * It is also safer because you can give a fallback executable name in case getExecutableName() could not determine
     * it.
     * <p>
     * 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.
     * <p>
     * You will probably never make use of this variant. It's meant to be a solution if all else seems to fail (e.g.
     * customer calls and you need a quick fix).
     * <p>
     * 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.
     * <p>
     * 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
     *                         e.g. 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<Object, Object> entry : properties.entrySet()) {
            System.out.println(entry);
        }

        System.out.println("\n\n\n\n----------------------------- System.getenv() ------------------------------");
        final Map<String, String> env = System.getenv();
        for (final Map.Entry<String, String> entry : env.entrySet()) {
            System.out.println(entry);
        }

        System.out.print("\n\n\n\n");
    }


}

import javax.swing.*；
导入java.io.File；
导入java.io.IOException；
导入java.security.CodeSource；
导入java.util.Map；
导入java.util.Properties；
/**
*由Reddit用户king_of the_universe/StackOverflow用户Dreamspace President/Dreamspace-President.com创建
*
*v[（2），2015-11-13 13:00 UTC]
*
*一个静态方法调用将在控制台中启动*THIS*应用程序的新实例，并将退出当前
*例如。到目前为止，只适用于WINDOWS！其他系统的用户需要在此提供帮助。这些方法都已到位。
*/
最终公共类控制台{
最终私有静态字符串失败消息\u TITLE=“请在控制台中运行。”；
final private static String FAILMESSAGE\u BODY=“此应用程序必须在控制台（或\“命令框\”）中运行。\n\n在此，您必须键入：\n\njava-jar nameofprogram.jar”；
私有静态void showFailMessageAndExit（）{
JOptionPane.showMessageDialog（null，FAILMESSAGE\u正文，FAILMESSAGE\u标题，JOptionPane.INFORMATION\u消息）；
系统出口（0）；
}
私有枚举OSType{
未确定，WINDOWS、LINUX、MACOS
}
私有静态OSType getOsType（）{
//最后一个字符串osName=System.getProperty（“os.name”）；
//最终字符串osVersion=System.getProperty（“os.version”）；
//最终字符串osArchitecture=System.getProperty（“os.arch”）；
//System.out.println（“\n\nOSNAME:”+osName）；
//System.out.println（“\n\nOSVERSION:+osVersion”）；
//System.out.println（“\n\n体系结构：“+osArchitecture”）；
最后一个字符串osName=System.getProperty（“os.name”，”）.toLowerCase（）；
if（osName.startsWith（“windows”））{
返回OSType.WINDOWS；
}else if（osName.startsWith（“linux”））{
返回OSType.LINUX；
}else if（osName.startsWith（“mac os”）| | osName.startsWith（“macos”）| | osName.startsWith（“达尔文”））{
返回OSType.MACOS；
}
返回OSType.undeminated；
}
/**
*检查该程序当前是否在控制台中运行，如果未运行，则从控制台启动该程序并退出此操作
*程序的实例。应该是程序中的第一个调用之一。
*
*这是该方法的一个不太安全的变体：要检查您当前是否在IDE中，它只会尝试查找
*可执行文件名，以及当前路径中是否存在该文件。这应该在