如何使java应用程序打开控制台/终端窗口？

我有没有办法制作一个可执行的.jar文件，在双击时打开命令行

---

我正在做一个基于文本的冒险游戏。到目前为止，这只是一个有房间的迷宫。最终它会变得更大更深入，但现在我只想把基本结构弄下来。无论如何，为了实现这一点，我一直在从System.out.printf命令和java.util.Scanner获取输出和输入。到目前为止，这一切都运行得很好，但我意识到，当我试图将它发送给不知道如何或只是不想从命令行运行程序的其他人时，我会遇到问题。

只要使用java.exe执行.jar，命令行窗口就会始终显示出来。用javaw.exe执行它可以防止这种情况

进一步阅读：

---

或者您可以提供一个.sh.bat来打开一个终端并在其中调用java。

双击一个jar，无论您在操作系统中与它关联的是什么应用程序，它都会打开。默认情况下，javaw[.exe]通常与jar文件关联。这是在没有终端窗口的情况下运行的二进制文件。要在双击时查看终端，您需要将java[.exe]二进制文件与jar文件相关联。

如果您想要完全控制，您可以在Swing中实现一个控制台窗口，该窗口将实现您现在拥有的功能

---

如果您无法打开所述窗口（如果无头）或用户在命令行上请求它，则默认为您当前的行为。

我自己在寻找答案时发现了这一点，最后我写了以下内容：

/**
 * This opens a command line and runs some other class in the jar
 * @author Brandon Barajas
 */
import java.io.*;
import java.awt.GraphicsEnvironment;
import java.net.URISyntaxException;
public class Main{
    public static void main (String [] args) throws IOException, InterruptedException, URISyntaxException{
        Console console = System.console();
        if(console == null && !GraphicsEnvironment.isHeadless()){
            String filename = Main.class.getProtectionDomain().getCodeSource().getLocation().toString().substring(6);
            Runtime.getRuntime().exec(new String[]{"cmd","/c","start","cmd","/k","java -jar \"" + filename + "\""});
        }else{
            THEMAINCLASSNAMEGOESHERE.main(new String[0]);
            System.out.println("Program has ended, please type 'exit' to close the console");
        }
    }
}

不确定我的答案是否仍然相关，但请随意使用，并将评论保存在o/

我能想到的唯一缺陷是，它在程序完成后使cmd窗口保持打开状态

---

用法：将该类与主类放在同一个包中，并将其设置为主类。如果未打开命令提示窗口，则会打开命令提示窗口；如果打开命令提示窗口，则会启动主类。jar文件的名称/位置是自动的。专为windows设计，但如果你想在另一个系统中使用它，请给我发消息，我会修复它。（我可以做操作系统检测，但我很懒，只是这样我就可以把一个双击的jar文件交给使用windows的教授。）

我想最简单的方法就是为jar文件编写一个简单的快捷方式。e、 eclipse（与大多数ide一样）能够导出包含所有必要库等的jar文件。因此，您只需设置快捷命令，如“java-jar filePath/file.jar”（filePath:e.g../bin/file.jar）

实现这一点的一种方法是使用命令“java-jar filePath/yourfile.jar”（不带“”）创建一个.bat文件。确保包含文件路径，否则将找不到您的文件。

---

虽然这个问题已经得到了回答，但这是一个简单的方法。

您可以使用Swing或Awt，使用文本窗格创建自己的窗口，唯一的问题是。。。是如何像cmd一样输入和使用。但你总是可以通过警报和所有

另一种方式是直接从批处理文件运行，显示在控制台上

<>你也应该考虑一下，直接在批次上做你的游戏…这是一种不错的语言，在每个Windows操作系统上都可以使用

（希望是有用的（'因为我是新手），我的英语也没那么差…）

使用Launch4j并在基本选项卡中在输出文件中指定exe名称，然后在jar选项卡中加载jar文件

转到页眉选项卡并选择Console

然后转到JRE选项卡，给出JRE版本，例如1.8.0

然后单击buildwrapper按钮（设置图标的种类）

它会要求您保存一个xaml文件，只需输入一些随机名称并单击“保存”

最后，您的.exe被创建，您现在可以运行了

---

这就是我的解决方案，我使用了@Brandon Barajas的代码并对其进行了修改。它创建一个批处理文件，该文件可以自行启动程序

public static void main(String[] args){
    Console console = System.console();
    if(console == null && !GraphicsEnvironment.isHeadless()) {
        String filename = YOURMAINCALSS.class.getProtectionDomain().getCodeSource().getLocation().toString().substring(6);
        try {
            File batch = new File("Launcher.bat");
            if(!batch.exists()){
                batch.createNewFile();
                PrintWriter writer = new PrintWriter(batch);
                writer.println("@echo off");
                writer.println("java -jar "+filename);
                writer.println("exit");
                writer.flush();
            }
            Runtime.getRuntime().exec("cmd /c start \"\" "+batch.getPath());
        } catch(IOException e) {
            e.printStackTrace();
        }
    } else {
        //your program code...
    }
}

---

如果需要，可以添加一个writer.println（“暂停”）在“退出”打印之前，在程序完成后保持窗口打开。然后你需要点击进入关闭窗口。

你可以使用这个程序。这个程序为JAR程序创建一个控制台（当通过双击JAR程序来运行它们时）

import java.io.*；
导入javax.swing.*；
导入javax.swing.event.*；
导入java.awt.*；
导入java.awt.event.*；
导入java.util.*；
导入javax.swing.text.*；
导入javax.swing.border.*；
类初始化组件{
公共静态JFrame设置JFrameAndGet（字符串标题、整型宽度、整型高度）{
JFrame tmpJF=新JFrame（标题）；
tmpJF.设置尺寸（宽度、高度）；
tmpJF.setLocationRelativeTo（空）；
tmpJF.setLayout（空）；
tmpJF.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
返回tmpJF；
}//setupJFrameAndGet的结束
公共静态JTextArea setupJTextAreaAndGet（字符串文本、int行、int列、布尔setEditableFlag、布尔setLineWrapFlag、布尔setWrapStyleWordFlag、布尔setBoundsFlag、int xpos、int ypos、int width、int height）{
JTextArea tmpJTA=新的JTextArea（文本、行、列）；
tmpJTA.setEditable（setEditableFlag）；
tmpJTA.setLineWrap（setLineWrapFlag）；
tmpJTA.setWrapStyleWord（setWrapStyleWordFlag）；
if（setBoundsFlag==true）{
tmpJTA.立根（xpos、YPO、宽度、高度）；
}
返回tmpJTA；
}//SetupJTextArea和Get的结束
公共静态JScrollPane设置可滚动的JTextArea和Get（JTextArea jta、int xpos、int ypos、int width、int height）{
JScrollPane tmpJSP=新的JScrollPane（jta）；
tmpJSP.setBounds（xpos、ypos、宽度、高度）；
返回tmpJSP；
}//设置ScrollableJTextArea和Get的结束
公共静态JMenuBar setupJMenuBarAndGet（）{
JMenuBar tmpJMB=新JMenuBar（）；
返回tmpJMB；
}//setupJMenuBarAndGet结束
公共静态JMenu setupJMenuAndGet（字符串文本）{
JMenu tmpJM=
import java.io.*;
import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.text.*;
import javax.swing.border.*;

class InitComponents {

    public static JFrame setupJFrameAndGet(String title, int width, int height) {
        JFrame tmpJF = new JFrame(title);
        tmpJF.setSize(width, height);
        tmpJF.setLocationRelativeTo(null);
        tmpJF.setLayout(null);
        tmpJF.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        return tmpJF;
    } // end of setupJFrameAndGet

    public static JTextArea setupJTextAreaAndGet(String text, int rows, int columns, boolean setEditableFlag, boolean setLineWrapFlag, boolean setWrapStyleWordFlag, boolean setBoundsFlag, int xpos, int ypos, int width, int height) {
        JTextArea tmpJTA = new JTextArea(text, rows, columns);
        tmpJTA.setEditable(setEditableFlag);
        tmpJTA.setLineWrap(setLineWrapFlag);
        tmpJTA.setWrapStyleWord(setWrapStyleWordFlag);
        if (setBoundsFlag == true) {
            tmpJTA.setBounds(xpos, ypos, width, height);
        }
        return tmpJTA;
    } // end of setupJTextAreaAndGet

    public static JScrollPane setupScrollableJTextAreaAndGet(JTextArea jta, int xpos, int ypos, int width, int height) {
        JScrollPane tmpJSP = new JScrollPane(jta);
        tmpJSP.setBounds(xpos, ypos, width, height);
        return tmpJSP;
    } // end of setupScrollableJTextAreaAndGet

    public static JMenuBar setupJMenuBarAndGet() {
        JMenuBar tmpJMB = new JMenuBar();
        return tmpJMB;
    } // end of setupJMenuBarAndGet

    public static JMenu setupJMenuAndGet(String text) {
        JMenu tmpJM = new JMenu(text);
        return tmpJM;
    } // end of setupJMenuAndGet

    public static JMenuItem setupJMenuItemAndGet(String text) {
        JMenuItem tmpJMI = new JMenuItem(text);
        return tmpJMI;
    } // end of setupJMenuItemAndGet

}// end of InitComponents

public class ConsoleForJARPrograms implements KeyListener, ActionListener {

    Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
    int screenWidth = screenSize.width;
    int screenHeight = screenSize.height;

    String title = null;
    String text = null;

    JFrame jf = null;
    JTextArea jta = null;
    JScrollPane jsp = null;
    JMenuBar jmb = null;
    JMenu jm = null;
    JMenuItem jmi = null;

    int initialCaretPosition = 0;
    int currentCaretPosition = 0;
    boolean inputAvailable = false;

    // key codes
    int BACKSPACE = 8;
    int ENTER = 10;
    int PG_UP = 33; // do nothing for this key pressed
    int PG_DN = 34; // do nothing for this key pressed
    int END = 35;
    int HOME = 36;
    int LEFT_ARROW = 37;
    int UP_ARROW = 38; // do nothing for this key pressed
    //int RIGHT_ARROW = 39; // handled by JTextArea
    int DOWN_ARROW = 40; // do nothing for this key pressed

    int CTRL = 128;
    int A = 65; // disable ctrl-a
    int H = 72; // handle ctrl-h
    //int DELETE = 127; // handled by JTextArea

    public void actionPerformed(ActionEvent ae) {
        int cCurrPos = jta.getCaretPosition();
        jta.selectAll();
        jta.copy();
        jta.select(cCurrPos, cCurrPos);
    } // end of actionPerformed

    public void keyTyped(KeyEvent ke) {
    } // end of keyTyped

    public void keyReleased(KeyEvent ke) {
    } // end of keyReleased

    public void keyPressed(KeyEvent ke) {
        int keyCode = ke.getKeyCode();
        if ((keyCode == PG_UP) || (keyCode == PG_DN) || (keyCode == UP_ARROW) || (keyCode == DOWN_ARROW) || ((keyCode == A) && (ke.getModifiersEx() == CTRL))) {
            ke.consume();
        } else if ((keyCode == LEFT_ARROW) || (keyCode == BACKSPACE) || ((keyCode == H) && (ke.getModifiersEx() == CTRL))) {
            synchronized(this) {
                if (jta.getCaretPosition() <= initialCaretPosition) {
                    ke.consume();
                }
            } // end of synchronized block
        } else if (keyCode == HOME) {
            synchronized(this) {
                jta.setCaretPosition(initialCaretPosition);
                ke.consume();
            } // end of synchronized block
        } else if (keyCode == END) {
            synchronized(this) {
                jta.setCaretPosition(jta.getDocument().getLength());
                ke.consume();
            } // end of synchronized block
        } else if (keyCode == ENTER) {
            jta.setCaretPosition(jta.getDocument().getLength());
            synchronized(this) {
                currentCaretPosition = jta.getCaretPosition();

                // If character at initial caret position is newline then it means that the user has
                // pressed enter without enetring any other character. Also, the code gets called here
                // as soon as enter is pressed which means that the caret position (jta.getCaretPosition())
                // of the document will be incremented by 1 by the system after this code returns.
                // This means that if at initial caret position, the character is newline, then we must ignore
                // this enter and increment initial caret position by 1 and do not set inputAvailable to true.
                try {
                    String charAtInitialCaretPosition = jta.getText(initialCaretPosition, 1);
                    if ((charAtInitialCaretPosition.equals("\n")) == true) {
                        initialCaretPosition++;
                    }
                } catch (Exception e) {
                }
                /*
                debug: start
                try {
                    System.out.println("keyPressed (1): initial = " + initialCaretPosition + ", current = " + currentCaretPosition + ", System current = " + jta.getDocument().getLength());
                    String initialString = jta.getText(initialCaretPosition, 1);
                    String currentString = jta.getText(currentCaretPosition, 1);
                    System.out.println("char at initial = " + initialString + ", char at current = " + currentString);
                    if ((initialString.equals("\n")) == true) {
                        System.out.println("char at initial is newline");
                    }
                    if ((currentString.equals("\n")) == true) {
                        System.out.println("char at current is newline");
                    }
                } catch (Exception e) {
                }
                debug:end
                */

                if ((currentCaretPosition - initialCaretPosition) > 0) {
                    inputAvailable = true;
                    notifyAll();
                }
            } // end of synchronized block
        } // end of if else if
    } // end of keyPressed

    String getInputFromJTextArea(JTextArea jta) {
        int len = 0;
        String inputFromUser = "";
        while (true) {
            synchronized(this) {
                if (inputAvailable == true) {
                    len = currentCaretPosition - initialCaretPosition;

                    try {
                        inputFromUser = jta.getText(initialCaretPosition, len);
                        initialCaretPosition = currentCaretPosition;
                    } catch (Exception e) {
                        inputFromUser = "";
                        return inputFromUser;
                    } // end of outer try catch

                    /*
                    The following lines of code are not needed now.
                    if ((len == 1) && (inputFromUser.equals("\n")) == true) {
                        try {
                            wait();
                            continue;
                        } catch (Exception e) {
                        } // end of try catch
                    } else if (Character.compare(inputFromUser.charAt(0), '\n') == 0) { // matched
                        // remove first character from inputFromUser
                        inputFromUser = inputFromUser.substring(1);
                    }
                    */
                    inputAvailable = false;
                    return inputFromUser;
                } else {
                    try {
                        wait();
                        continue;
                    } catch (Exception e) {
                    } // end of try catch
                } // end of if else inputAvailable
            } // end of synchronized block
        } // end of while true
    } // end of getInoutFromJtextArea

    void outputToJTextArea(JTextArea jta, String text) {
        jta.append(text);
        jta.setCaretPosition(jta.getDocument().getLength());
        synchronized(this) {
            initialCaretPosition = jta.getCaretPosition();
        }
    } // end of outputToJTextArea

    void begin() {
        while (true) {
            outputToJTextArea(jta, "Enter some input (press enter after inputting): ");
            String input = getInputFromJTextArea(jta);
            outputToJTextArea(jta, "User input was: " + input + "\n\n");
        }
    } // end of begin

    void configureJTextAreaForInputOutput(JTextArea jta) {
        jta.addKeyListener(this);

        // remove all mouse listeners
        for (MouseListener listener : jta.getMouseListeners()) {
            //outputToJTextArea(jta, "\nRemoving mouse listener\n");
            jta.removeMouseListener(listener);
        }

        // remove all mouse motion listeners
        for (MouseMotionListener listener : jta.getMouseMotionListeners()) {
            //outputToJTextArea(jta, "\nRemoving mouse motion listener\n");
            jta.removeMouseMotionListener(listener);
        }

        // remove all mouse wheel listeners
        for (MouseWheelListener listener : jta.getMouseWheelListeners()) {
            //outputToJTextArea(jta, "\nRemoving mouse wheel listener\n");
            jta.removeMouseWheelListener(listener);
        }
    } // end of configureJTextAreaForInputOutput

    void createAndShowGUI() {
        title = "Console";
        jf = InitComponents.setupJFrameAndGet(title, screenWidth - 150, screenHeight - 100);

        jta = InitComponents.setupJTextAreaAndGet("", 1000, 100, true, true, true, false, 0, 0, 0, 0);
        configureJTextAreaForInputOutput(jta);

        jsp = InitComponents.setupScrollableJTextAreaAndGet(jta, 10, 10, screenWidth - 180, screenHeight - 180);
        jsp.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
        jsp.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);
        jf.add(jsp);
        //jf.setLocation(screenWidth / 5, screenHeight / 6);

        jmb = InitComponents.setupJMenuBarAndGet();
        jm = InitComponents.setupJMenuAndGet("Copy All to Clipboard");
        jm.setBorder(BorderFactory.createLineBorder(Color.green, 2));
        jmi = InitComponents.setupJMenuItemAndGet("Copy All to Clipboard");
        jm.add(jmi);
        jmb.add(jm);
        jmi.addActionListener(this);
        jf.setJMenuBar(jmb);

        jf.setVisible(true);
    } // end of createAndShowGUI

    public static void main(String[] args) {
        ConsoleForJARPrograms cfjp = new ConsoleForJARPrograms();
        cfjp.createAndShowGUI();
        cfjp.begin();
    } // end of main

} // end of ConsoleForJARPrograms

java -cp myproject.jar; bar.foo