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

时间:2014-03-11 22:52:55

标签: java file icons exe double-click

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

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

那么有没有办法用JAVA做这样的事情?

提前致谢:)

2 个答案:

答案 0 :(得分:4)

创建batsh文件,具体取决于操作系统,并将java -jar ApplicationName.jar放入该文件中。

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

Windows示例:

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

答案 1 :(得分:1)

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

它的作用:

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

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

  2. 如果你有一个控制台,它就会返回。

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

  4. 使用方法:

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

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

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

    4. 工作原理:

      确定正在运行的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");
          }
      
      
      }