java中KeyAdapter輸入不工作

我剛寫了一些代碼讓我的玩家在我的小迷宮遊戲中移動，但沒有任何反應。我的迷宮也不像矩陣輸入那樣正確。我不明白爲什麼這個代碼是錯誤的......任何幫助都很好。謝謝！java中KeyAdapter輸入不工作

import java.awt.Graphics; 
import java.awt.Image; 
import java.awt.event.*; 
import java.util.ArrayList; 
import java.util.List; 
import java.util.Scanner; 
import javax.swing.*; 

public class Main extends JPanel { 
    private static Image white; 
    private static Image black; 
    private static Image finish; 
    private static Image player; 
    private static int x = 1; 
    private static int y = 1; 
    private String matrix[][]; 

    public Main() { 
     addKeyListener(new Keys()); 
     setFocusable(true); 
    } 

    public static String[][] load(String input) { 
     List<String[]> rows = new ArrayList<>(); 
     try (Scanner scanner = new Scanner(input)) { 
      while (scanner.hasNextLine()) { 
       String line = scanner.nextLine(); 
       String[] cols = new String[line.length()]; 
       for (int i = 0; i < cols.length; i++) { 
        cols[i] = line.substring(i, i + 1); 
       } 
       rows.add(cols); 
      } 
     } 
     return rows.toArray(new String[rows.size()][]); 
    } 

    public static JFrame buildFrame() { 
     JFrame frame = new JFrame("Labyrinth Game"); 
     frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
     frame.setSize(900, 950); 
     frame.setLocationRelativeTo(null); 
     frame.setVisible(true); 
     return frame; 
    } 

    public void moveUp() { 
     x += 0; 
     y += -1; 
    } 

    public void moveLeft() { 
     x += -1; 
     y += 0; 
    } 

    public void moveDown() { 
     x += 0; 
     y += 1; 
    } 

    public void moveRight() { 
     x += 1; 
     y += 0; 
    } 

    public class Keys extends KeyAdapter { 
     @Override 
     public void keyPressed(KeyEvent e) { 
      int keycode = e.getKeyCode(); 
      // repaint(); 
      if (keycode == KeyEvent.VK_W) { 
       if (!matrix[getX()][getY() - 1].equals("1")) { 
        moveUp(); 
       } 
      } 
      if (keycode == KeyEvent.VK_A) { 
       if (!matrix[getX() - 1][getY()].equals("1")) { 
        moveLeft(); 
       } 
      } 
      if (keycode == KeyEvent.VK_S) { 
       if (!matrix[getX()][getY() + 1].equals("1")) { 
        moveDown(); 
       } 
      } 
      if (keycode == KeyEvent.VK_D) { 
       if (!matrix[getX() + 1][getY()].equals("1")) { 
        moveRight(); 
       } 
      } 
     } 

     @Override 
     public void keyReleased(KeyEvent event) { 
     } 
    } 

    public static void main(String[] args) { 
     String input = "1111111111111111111111111111111111111111111\n" 
       + "1000000010001000001000000010000000100000001\n" 
       + "1010111010101010101111101011111010111111101\n" 
       + "1010001010100010100000001010000010000010001\n" 
       + "1011101010111110101111111010111111111010111\n" 
       + "1000101010100000101000001000100010000010001\n" 
       + "1011101011101011111011101111111010111110101\n" 
       + "1010001000001010000010100000001010000010101\n" 
       + "1010111111111010111110111111101011111011101\n" 
       + "1010100000100010100000000000101000000000101\n" 
       + "1110101111101110111110111011101011111110101\n" 
       + "1000100000000010000010100010001000100010001\n" 
       + "1011111111111111111011101010111111101011101\n" 
       + "1000000000000000100010001010000000001010001\n" 
       + "1011111111111011101110111011111111111010111\n" 
       + "1000100010001000001010001000100000001010101\n" 
       + "1110101011101111111010101110111110111010101\n" 
       + "1000101010001000100000101000100000100010001\n" 
       + "1011101010111010101111101011101110101111111\n" 
       + "1000001010000010000000101000001000100010001\n" 
       + "1111111011111110111111101111111011111010101\n" 
       + "1000001010000010100010001000000010000010101\n" 
       + "1011111010111011101010111011111110101110101\n" 
       + "1010000010001010001010001000100000101010101\n" 
       + "1010111111101010111011101111101111101011101\n" 
       + "1000100000001010101010001000100010101000101\n" 
       + "1011111011111010101010111010111010101011101\n" 
       + "1010000010001000101010000010001010001000001\n" 
       + "1010101110101111101011101111101011111010101\n" 
       + "1010101000101000001000101000001000000010101\n" 
       + "1011101011111010111110111011101111111110111\n" 
       + "1000001000000010000000000010000000000010021\n" 
       + "1111111111111111111111111111111111111111111\n"; 

     String[][] matrix = load(input); 

     JFrame frame = buildFrame(); 
     ImageIcon img = new ImageIcon("C:/Users/Desktop/black20.png"); 
     black = img.getImage(); 
     img = new ImageIcon("C:/Users/Desktop/gri20.png"); 
     white = img.getImage(); 
     img = new ImageIcon("C:/Users/Desktop/finish20.png"); 
     finish = img.getImage(); 
     img = new ImageIcon("C:/Users/Desktop/smiley20.png"); 
     player = img.getImage(); 
     // frame.add(new Player()); 
     JPanel pane = new JPanel() { 
      @Override 
      public void paint(Graphics g) { 
       super.paint(g); 
       for (int i = 0; i < matrix.length; i++) { 
        for (int j = 0; j < matrix[0].length; j++) { 
         if (matrix[i][j].equals("1")) { 
          g.drawImage(black, i * 20, j * 20, null); 
         } 
         if (matrix[i][j].equals("0")) { 
          g.drawImage(white, i * 20, j * 20, null); 
         } 
         if (matrix[i][j].equals("2")) { 
          g.drawImage(finish, i * 20, j * 20, null); 
         } 
        } 
       } 
       g.drawImage(player, x * 20, y * 20, null); 
      } 
     }; 
     frame.add(pane); 
     frame.add(new Main()); 
    } 
}

它應該看起來像：

來源

2017-01-01 Nico

1.根據很多類似的問題，**不要使用KeyAdapaters和KeyListeners **。而是使用鍵綁定，因爲這將幫助您解決任何焦點問題。 2.進行一些初步調試，包括使用println來查看何時調用哪些代碼。 3.由於您重寫了關鍵的JPanel方法，用於將JPanel放入GUI的方法，並且您可能不知道您正在執行此操作，所以'getX（）'和'getY（）'方法會咬你。 –

@JoãoPiresBarreira：請不要在編輯評論的問題！ –

其他問題：1）在添加所有組件之前調用'setVisible（true）'。 2）重寫'paint'而不是'paintComponent'。 3）將多個組件添加到JFrame並忽略其佈局管理器。 4）不是爲了我們的利益而創建和發佈一個有效的[mcve]，也是爲了你 - 讓你測試你的主要問題，KeyListener問題，與你的其他代碼隔離開來...... –

-1

問題/建議：

你在默認的方式加入多個組件到JFrame。由於JFrame的contentPane使用BorderLayout，因此只會顯示一個組件，添加最後一個組件，另一個組件將被完全覆蓋並保持不可見狀態。
您的主JPanel未被用作真正的JPanel。沒有什麼被添加到它，實際上它看起來應該是一個邏輯類而不是組件類。
而不是使用KeyListeners，當談到焦點問題時非常煩躁，使用Key Bindings，這將允許您以乾淨和更高級別的方式解決焦點問題。
不要重寫JPanel的繪製方法，而應該重寫它的paintComponent方法，因爲這會給你帶來一些好處，包括對動畫默認使用雙緩衝。
不要輕易給出組件類別public int getX()和public int getY()方法，因爲這些方法會覆蓋將組件放置在其容器中的關鍵方法。由於Main類甚至不應該擴展JPanel，所以這對您的代碼來說不會成爲問題，但是將來它會讓程序變得糟糕。
當您遇到類似問題（例如KeyListener無法正常工作）時，請從大程序中刪除該問題，並嘗試在一個小型單獨程序中重現該問題。這將爲您提供更清潔的環境，幫助您隔離和理解您的問題，從而幫助您解決問題。
您的程序錯誤使用了靜態修飾符。你的x和y字段不應該是靜態的，不應該以靜態方式訪問。
您的主要方法中存在太多代碼，這是您可能將x和y設置爲靜態的原因之一，因爲您嘗試在main中訪問它們時被迫這樣做。解決方案不是讓這些字段成爲靜態的，而是將所有代碼從靜態世界中移出並進入實例世界。

編輯

出於某種原因，這個問題吸引了我，所以我決定嘗試M-V-C或模型 - 視圖 - 控制器，如果可能，看看我能想出。所以這裏有一些類的工作，從一個包含數據的文本文件開始。

的GUI看起來像：

，因爲它是作爲一個資源獲得，必須有文件名"input.txt"

1111111111111111111111111111111111111111111 
1000000010001000001000000010000000100000001 
1010111010101010101111101011111010111111101 
1010001010100010100000001010000010000010001 
1011101010111110101111111010111111111010111 
1000101010100000101000001000100010000010001 
1011101011101011111011101111111010111110101 
1010001000001010000010100000001010000010101 
1010111111111010111110111111101011111011101 
1010100000100010100000000000101000000000101 
1110101111101110111110111011101011111110101 
1000100000000010000010100010001000100010001 
1011111111111111111011101010111111101011101 
1000000000000000100010001010000000001010001 
1011111111111011101110111011111111111010111 
1000100010001000001010001000100000001010101 
1110101011101111111010101110111110111010101 
1000101010001000100000101000100000100010001 
1011101010111010101111101011101110101111111 
1000001010000010000000101000001000100010001 
1111111011111110111111101111111011111010101 
1000001010000010100010001000000010000010101 
1011111010111011101010111011111110101110101 
1010000010001010001010001000100000101010101 
1010111111101010111011101111101111101011101 
1000100000001010101010001000100010101000101 
1011111011111010101010111010111010101011101 
1010000010001000101010000010001010001000001 
1010101110101111101011101111101011111010101 
1010101000101000001000101000001000000010101 
1011101011111010111110111011101111111110111 
1000001000000010000000000010000000000010021 
1111111111111111111111111111111111111111111

它必須是在同一個位置的類文件接下來，主程序（創建模型，視圖和控制器的程序）將它們連接在一起，然後顯示GUI：

import java.awt.BorderLayout; 
import javax.swing.JFrame; 
import javax.swing.JPanel; 
import javax.swing.SwingUtilities; 

/** 
* link: http://stackoverflow.com/a/41418250/522444 
* 
* @author Pete 
* 
*/ 
@SuppressWarnings("serial") 
public class Main2 extends JPanel { 
    private View mainPanel; 

    public Main2(MatrixModel matrixModel) { 
     mainPanel = new View(matrixModel); 
     new Controller(matrixModel, mainPanel); 

     setLayout(new BorderLayout()); 
     add(mainPanel, BorderLayout.CENTER); 
    } 

    private static void createAndShowGui(MatrixModel model) { 
     Main2 mainPanel = new Main2(model); 

     JFrame frame = new JFrame("Main2"); 
     frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
     frame.getContentPane().add(mainPanel); 
     frame.pack(); 
     frame.setLocationRelativeTo(null); 
     frame.setVisible(true); 
    } 

    public static void main(String[] args) { 
     final MatrixModel model = MatrixUtil.getInput(MatrixUtil.PATH_TO_RSC); 

     SwingUtilities.invokeLater(new Runnable() { 
      public void run() { 
       createAndShowGui(model); 
      } 
     }); 
    } 
}

接着一個工具類與靜態方法，用於讀取文本文件作爲資源，並將其轉換成模型對象：

import java.io.InputStream; 
import java.util.ArrayList; 
import java.util.List; 
import java.util.Scanner; 

public class MatrixUtil { 
    // again this text file must be in the jar file or the code base 
    // at the same location as the class/java files 
    public static final String PATH_TO_RSC = "input.txt"; 

    public static MatrixModel getInput(String resourcePath) { 
     InputStream is = MatrixUtil.class.getResourceAsStream(resourcePath); 
     if (is == null) { 
      String text = "resourcePath is not found and not loading text: " + resourcePath; 
      throw new IllegalArgumentException(text); 
     } 
     return getInput(is); 
    } 

    public static MatrixModel getInput(InputStream is) { 
     MatrixModel model = null; 
     try (Scanner scan = new Scanner(is)) { 
      List<List<MatrixPosition>> listOfLists = new ArrayList<>(); 
      while (scan.hasNextLine()) { 
       String line = scan.nextLine(); 
       if (line.trim().isEmpty()) { 
        continue; 
       } 
       List<MatrixPosition> list = new ArrayList<>(); 
       for (char c : line.toCharArray()) { 
        list.add(MatrixPosition.getMatrixPosition(String.valueOf(c))); 
       } 
       listOfLists.add(list); 
      } 
      MatrixPosition[][] grid = new MatrixPosition[listOfLists.size()][]; 
      for (int i = 0; i < grid.length; i++) { 
       List<MatrixPosition> list = listOfLists.get(i); 
       grid[i] = list.toArray(new MatrixPosition[] {}); 
      } 
      model = new MatrixModel(grid, new SpritePosition(1, 1)); 
     } 

     return model; 
    } 

}

基本枚舉來表示方向：

public enum Direction { 
    UP, DOWN, LEFT, RIGHT 
}

另一個枚舉以表示網格中的位置點，以及是否是牆，coridor或結束以及從數字轉換爲MatrixPosition的靜態方法：

public enum MatrixPosition { 
    WALL(1), CORRIDOR(0), END(2); 

    private int value; 

    private MatrixPosition(int value) { 
     this.value = value; 
    } 

    public int getValue() { 
     return value; 
    } 

    public static MatrixPosition getMatrixPosition(int value) { 
     for (MatrixPosition position : MatrixPosition.values()) { 
      if (value == position.getValue()) { 
       return position; 
      } 
     } 
     String text = "value of " + value; 
     throw new IllegalArgumentException(text); 
    } 

    public static MatrixPosition getMatrixPosition(String strValue) { 
     int value = -1; 
     try { 
      value = Integer.parseInt(strValue); 
     } catch (NumberFormatException e) { 
      String text = "NumberFormatException for strValue " + strValue; 
      throw new IllegalAccessError(text); 
     } 
     return getMatrixPosition(value); 
    } 
}

一個類來表示我們的精靈的位置，類似於java.awt.Point類，但與行和列字段，而不是x和y：

public class SpritePosition { 
    int row; 
    int column; 

    public SpritePosition(int row, int column) { 
     this.row = row; 
     this.column = column; 
    } 

    public int getRow() { 
     return row; 
    } 

    public void setRow(int row) { 
     this.row = row; 
    } 

    public int getColumn() { 
     return column; 
    } 

    public void setColumn(int column) { 
     this.column = column; 
    } 

    public void setRowColumn(int row, int column) { 
     this.row = row; 
     this.column = column; 
    } 

}

該模型屬性更改的支持代碼，以便它可以通知任何聽取其狀態變化的類。該控制器將是類收聽模式

import java.beans.PropertyChangeListener; 
import javax.swing.event.SwingPropertyChangeSupport; 

public class MatrixModel { 
    public static final String SPRITE_POINT = "sprite point"; 
    private SwingPropertyChangeSupport pcSupport = new SwingPropertyChangeSupport(this); 
    private MatrixPosition[][] grid; 
    private SpritePosition spritePosition; 

    public MatrixModel(MatrixPosition[][] grid, SpritePosition spritePosition) { 
     this.grid = grid; 
     this.spritePosition = spritePosition; 
    } 

    public int getRows() { 
     return grid.length; 
    } 

    public int getColumns() { 
     return grid[0].length; 
    } 

    public MatrixPosition getPosition(SpritePosition p) { 
     return getPosition(p.row, p.column); 
    } 

    public MatrixPosition getPosition(int row, int col) { 
     return grid[row][col]; 
    } 

    public void setSpritePoint(SpritePosition spritePosition) { 
     SpritePosition oldValue = this.spritePosition; 
     SpritePosition newValue = spritePosition; 
     this.spritePosition = spritePosition; 
     pcSupport.firePropertyChange(SPRITE_POINT, oldValue, newValue); 
    } 

    public boolean isPointValid(SpritePosition p) { 
     if (p.column < 0 || p.row < 0) { 
      return false; 
     } 
     if (p.column >= grid[0].length || p.row >= grid.length) { 
      return false; 
     } 
     return grid[p.row][p.column] == MatrixPosition.CORRIDOR; 
    } 

    public boolean isMoveValid(Direction direction) { 
     int row = spritePosition.row; 
     int column = spritePosition.column; 
     switch (direction) { 
     case UP: 
      return isPointValid(new SpritePosition(row - 1, column)); 
     case DOWN: 
      return isPointValid(new SpritePosition(row + 1, column)); 
     case LEFT: 
      return isPointValid(new SpritePosition(row, column - 1)); 
     case RIGHT: 
      return isPointValid(new SpritePosition(row, column + 1)); 
     default: 
      return false; 
     } 
    } 

    public void move(Direction direction) { 
     if (!isMoveValid(direction)) { 
      String text = "For move to " + direction + "spritePosition: " + spritePosition; 
      throw new IllegalArgumentException(text); 
     } 
     int row = spritePosition.row; 
     int column = spritePosition.column; 
     switch (direction) { 
     case UP: 
      setSpritePoint(new SpritePosition(row - 1, column)); 
      break; 
     case DOWN: 
      setSpritePoint(new SpritePosition(row + 1, column)); 
      break; 
     case LEFT: 
      setSpritePoint(new SpritePosition(row, column - 1)); 
      break; 
     case RIGHT: 
      setSpritePoint(new SpritePosition(row, column + 1)); 
      break; 

     default: 
      break; 
     } 
    } 

    public SpritePosition getSpritePosition() { 
     return spritePosition; 
    } 

    public void addPropertyChangeListener(PropertyChangeListener listener) { 
     pcSupport.addPropertyChangeListener(listener); 
    } 

    public void removePropertyChangeListener(PropertyChangeListener listener) { 
     pcSupport.removePropertyChangeListener(listener); 
    } 

    public void addPropertyChangeListener(String name, PropertyChangeListener listener) { 
     pcSupport.addPropertyChangeListener(name, listener); 
    } 

    public void removePropertyChangeListener(String name, PropertyChangeListener listener) { 
     pcSupport.removePropertyChangeListener(name, listener); 
    } 
}

Controller類，一個是設置鍵綁定的視圖，以便它可以監聽按鍵，檢查它們是否代表一個有效的舉措，如果這樣的話告訴模型做出這個舉動。它還增加了一個偵聽器添加到模型，以便其狀態改變時，它會告訴視圖移動精靈

import java.awt.event.ActionEvent; 
import java.awt.event.KeyEvent; 
import java.beans.PropertyChangeEvent; 
import java.beans.PropertyChangeListener; 
import java.util.EnumMap; 
import java.util.Map; 

import javax.swing.AbstractAction; 
import javax.swing.ActionMap; 
import javax.swing.InputMap; 
import javax.swing.JComponent; 
import javax.swing.KeyStroke; 

public class Controller { 
    private MatrixModel model; 
    private View view; 
    private Map<Direction, KeyStroke> dirKeyMap = new EnumMap<>(Direction.class); 

    public Controller(MatrixModel model, View view) { 
     this.model = model; 
     this.view = view; 

     dirKeyMap.put(Direction.DOWN, KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0)); 
     dirKeyMap.put(Direction.UP, KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0)); 
     dirKeyMap.put(Direction.LEFT, KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, 0)); 
     dirKeyMap.put(Direction.RIGHT, KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, 0)); 

     model.addPropertyChangeListener(new ModelListener()); 
     setUpKeyBindings(view); 
    } 

    private void setUpKeyBindings(View view) { 
     int condition = JComponent.WHEN_IN_FOCUSED_WINDOW; 
     InputMap inputMap = view.getInputMap(condition); 
     ActionMap actionMap = view.getActionMap(); 
     for (Direction dir : Direction.values()) { 
      KeyStroke keyStroke = dirKeyMap.get(dir); 
      hookUp(inputMap, actionMap, dir, keyStroke); 
     } 
    } 

    private void hookUp(InputMap inputMap, ActionMap actionMap, Direction dir, KeyStroke key) { 
     inputMap.put(key, key.toString()); 
     actionMap.put(key.toString(), new MoveAction(dir, model)); 
    } 

    public MatrixModel getModel() { 
     return model; 
    } 

    public View getView() { 
     return view; 
    } 

    class ModelListener implements PropertyChangeListener { 
     @Override 
     public void propertyChange(PropertyChangeEvent evt) { 
      if (MatrixModel.SPRITE_POINT.equals(evt.getPropertyName())) { 
       SpritePosition p = model.getSpritePosition(); 
       view.setSpritePoint(p); 
      } 
     } 
    } 

} 

@SuppressWarnings("serial") 
class MoveAction extends AbstractAction { 
    private Direction dir; 
    private MatrixModel model; 

    public MoveAction(Direction dir, MatrixModel model) { 
     super(dir.toString()); 
     this.dir = dir; 
     this.model = model; 
    } 

    public void actionPerformed(ActionEvent e) { 
     if (model.isMoveValid(dir)) { 
      model.move(dir); 
     } 
    } 
}

最後View類，即擴展JPanel，顯示的迷宮精靈：

import java.awt.Color; 
import java.awt.Dimension; 
import java.awt.Graphics; 
import java.awt.Graphics2D; 
import java.awt.image.BufferedImage; 
import javax.swing.JPanel; 

@SuppressWarnings("serial") 
public class View extends JPanel { 
    private static final int CELL_WIDTH = 20; 
    private static final Color CORRIDOR_COLOR = Color.LIGHT_GRAY; 
    private static final Color WALL_COLOR = Color.DARK_GRAY; 
    private static final Color END_COLOR = Color.ORANGE; 
    private static final Color SPRITE_COLOR = Color.RED; 
    private static final int GAP = 1; 
    private BufferedImage gridImg = null; 
    private SpritePosition spritePosition; 
    private JPanel mainPanel = new JPanel(); 

    public View(MatrixModel matrixModel) { 
     gridImg = createImg(matrixModel); 
     spritePosition = matrixModel.getSpritePosition(); 
    } 

    public JPanel getMainPanel() { 
     return mainPanel; 
    } 

    @Override 
    public Dimension getPreferredSize() { 
     if (isPreferredSizeSet() || gridImg == null) { 
      return super.getPreferredSize(); 
     } 
     int prefW = gridImg.getWidth(); 
     int prefH = gridImg.getHeight(); 
     return new Dimension(prefW, prefH); 
    } 

    public void setSpritePoint(SpritePosition spritePosition) { 
     this.spritePosition = spritePosition; 
     repaint(); 
    } 

    @Override 
    protected void paintComponent(Graphics g) { 
     super.paintComponent(g); 
     if (gridImg != null) { 
      g.drawImage(gridImg, 0, 0, this); 
     } 
     g.setColor(SPRITE_COLOR); 
     int y = spritePosition.row * CELL_WIDTH + GAP; 
     int x = spritePosition.column * CELL_WIDTH + GAP; 
     g.fillRect(x, y, CELL_WIDTH - 2 * GAP, CELL_WIDTH - 2 * GAP); 
    } 

    private BufferedImage createImg(MatrixModel matrixModel) { 
     BufferedImage img = null; 
     if (matrixModel != null && matrixModel.getRows() > 0) { 
      int w = matrixModel.getColumns() * CELL_WIDTH; 
      int h = matrixModel.getRows() * CELL_WIDTH; 
      img = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB); 
      Graphics2D g2 = img.createGraphics(); 
      for (int row = 0; row < matrixModel.getRows(); row++) { 
       for (int col = 0; col < matrixModel.getColumns(); col++) { 
        MatrixPosition position = matrixModel.getPosition(row, col); 
        Color c = null; 
        switch (position) { 
        case CORRIDOR: 
         c = CORRIDOR_COLOR; 
         break; 
        case WALL: 
         c = WALL_COLOR; 
         break; 
        case END: 
         c = END_COLOR; 
         break; 
        } 
        g2.setColor(c); 
        int x = col * CELL_WIDTH; 
        int y = row * CELL_WIDTH; 
        g2.fillRect(x, y, CELL_WIDTH, CELL_WIDTH); 
       } 
      } 
      g2.dispose(); 
     } 
     return img; 
    } 

}

來源

2017-01-01 19:19:10

我應該在哪裏放置枚舉？在哪個級別？ – Nico

@Nico：enums參加他們自己的班級。 –

我在閱讀input.txt文件時遇到問題。我把它放在項目的src文件中，我仍然得到了「resourcePath未找到並且沒有加載文本：」異常。我使用的路徑：「E：/ Facultate/Anul 2/Semestrul 1/POO/Labyrinth game/src/input.txt」或「input.txt」，沒有任何作品... @HovercraftFullOfEels – Nico

java中KeyAdapter輸入不工作

回答

相關問題