如何将另一个类中的对象传递给paintComponent方法？

Question

我的任务是创建游戏“ FloodIt”。 如果您需要了解游戏，可以在这里玩，但我认为这不是真正必要的： http : //unixpapa.com/floodit/

我已经完成了游戏的实际部分，但是现在我需要为其制作图形界面。 我有三节课：

Board.java，它使板子具有随机的int值，并包含其他几种使游戏正常工作的方法：

import java.awt.Color;
import java.util.Random;


/**The board class for the Flood-It game.  This class implements a NxN board filled with numColors colors.
 * The class implements several methods to allow the playing of the game.
 */

class Board {

//you will probably need to create some field variables
private int size;
private int numColors;
private int[][] board;
private int numOfMoves;
/**Constructs a new sizeXsize board filled where each element on the board is a random number between 0
 * and numColors.  Also initializes the number of moves to zero.
 * @param size -- the size of the board
 * @param numColors -- the number of possible entries on the board
 */
public Board(int size,int numColors) {
    //TODO finish this constructor
    this.size = size;
    this.numColors = numColors;
    numOfMoves = 0;



    board = new int[size][size];
    Random rand = new Random();
    int randomNum = 0;
    for (int count = 0; count < size; count++) {
        for (int counter = 0; counter < size; counter++) {
            randomNum = rand.nextInt(this.numColors);
            board[count][counter] = randomNum;
        }
    }


}


/**Updates the board to fill (from the top left corner) with a specified color.  
 * Filling stops when any other color is hit besides the one in the top left corner.
 * Play the game at http://www.lemoda.net/javascript/flood-it/ or http://unixpapa.com/floodit/?sz=14&nc=4
 * to get a better understanding of what this method should do.
 * You will probably also want to take a look at the algorithm described
 * at http://en.wikipedia.org/wiki/Flood_fill which describes what this method should do.
 * I recommend the Stack-based recursive implementation.  It is a recursive algorithm for
 * flooding the board.  It is one of the easier ones to implement.
 * You are free to have this method call other methods.  I would recommend creating a private method that
 * this method calls and have that private method be the recursive method.
 * A recursive method is one that calls itself.
 * @param color -- the new color to flood the board with.
 */
public void move(int replacementColor) {
    int targetColor = board[0][0];
    recursiveMove(0,0,targetColor,replacementColor);
    numOfMoves++;
}

private void recursiveMove(int xCoord, int yCoord, int targetColor, int replacementColor) {
    if (targetColor == replacementColor) {
        return;
    }
    if (board[xCoord][yCoord] != targetColor) {
        return;
    }

    board[xCoord][yCoord] = replacementColor;
    if (yCoord != size-1) {
        recursiveMove(xCoord,yCoord+1,targetColor,replacementColor);
    }
    if (yCoord != 0) {
        recursiveMove(xCoord,yCoord-1,targetColor,replacementColor);
    }
    if (xCoord != 0) {
        recursiveMove(xCoord-1,yCoord,targetColor,replacementColor);
    }
    if (xCoord != size-1) {
        recursiveMove(xCoord+1,yCoord,targetColor,replacementColor);
    }
}


/**returns true if the board is not completely filled with a single color.
 * Otherwise it returns false.
 * @return true if board is all one color
 */
public boolean finished() {
    //TODO finish this method
    for (int count = 0; count < size; count++) {
        for (int counter = 0; counter < size; counter++) {
            if (board[count][counter] != board[0][0]) {
                return false;
            }
        }
    }
    return true;
}


/**returns how many times the move() method has been called.
 * @return the number of times the move() method has been called.
 */
public int numMoves() {
    //TODO finish this method
    return numOfMoves;
}


/**Returns a string representation of the board.  Use tabs between elements of the board.
 * And have every row of the board be separated by a newline character.
 * Example:
 * "1\t0\t3\t\n2\t0\t2\t\n1\t0\t1\t\n"
 * @return a String representation of the board
 */
public String toString() {
    //TODO finish this method
    String boardString = "";
    for (int count = 0; count < board.length; count++) {
        for (int counter = 0; counter < board.length; counter++) {
            boardString += board[count][counter];
            boardString += "\t";
        }
        boardString += "\n";
    }
    return boardString;
}
}

FloodIt.java，其中包含用于加载图形界面的JFrame行，以及用于实际运行游戏的代码（由于卡住，它还没有完全完成）：

import java.util.Scanner;
import javax.swing.JFrame;

/**This class is the main method for the Flood-It game as found on many web sites 
 * ( such as http://www.lemoda.net/javascript/flood-it/ or 
http://unixpapa.com/floodit/?sz=14&nc=4 ).
 * It prompts the user for the size of the board
 * and the number of colors.  The user is prompted for the next color until the board is flooded.
 * After the game is over it prints how many turns the user took and then asks if they want to play again.
 */
class FloodIt {

private static final int FRAMESIZE = 1000;

public static void main(String args[]) {
    JFrame frame = new JFrame();
    frame.setSize(FRAMESIZE,FRAMESIZE);
    frame.setTitle("Brennan's Game");
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    GraphicalBoard component = new GraphicalBoard();
    frame.add(component);
    frame.setVisible(true);

    String again="";
    int size = 20;
    int numColors = 7;
    do {
        Board board=new Board(size,numColors);
        while(!board.finished()) {
            //I will change the print statements below into graphical input boxes later
            System.out.print("****************\n"+board+"\n****************\n");
            System.out.print("What color do you choose? ");
            int color=Integer.parseInt(scan.nextLine());
            board.move(color);
        }
        System.out.println("Nice job, you finished in "+board.numMoves());
        System.out.print("Would you like to play again (Y/N)? ");
        again=scan.nextLine();
    } while (again.equalsIgnoreCase("Y"));
    scan.close();
}
}

还有GraphicalBoard.java，应该从Board.java获取2d数组的值，并在图形界面中显示板。 2d数组中可能存在的每个数字都与Colors数组中的颜色相对应：

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import javax.swing.JComponent;

public class GraphicalBoard extends JComponent {
private int xSize = 50;
private int ySize = 50;
public void paintComponent(Graphics g, int size, Board board) {
    String colors[] = {"BLUE","GREEN","YELLOW","RED","BLACK","ORANGE","PINK"};
    Graphics2D g2 = (Graphics2D) g;
    int xCoord = 0;
    int yCoord = 0;
    int colorNum = 0;
    String colorOfSquare = "";
    for (int count = 0; count < size; count++) {
        for (int counter = 0; counter < size; counter++) {
            colorNum = board[count][counter];
            colorOfSquare = colors[colorNum];
            g2.setColor(Color.colorOfSquare);
            Rectangle square = new Rectangle(xCoord,yCoord,xSize,ySize);
            xCoord += 50;
        }
        yCoord += 50;
    }
}

}

两个问题：

1. 在GraphicalBoard.java中，在“ colorNum = board [count] [counter];”行上，出现错误：“表达式的类型必须是数组类型，但必须解析为Board。”

我似乎在将已经初始化的板从Board.java类转移到GraphicalBoard.java类时遇到问题。

2. 在GraphicalBoard.java中，在“ g2.setColor（Color.colorOfSquare）;”行中，出现错误：“ colorOfSquare无法解析或它不是字段。”

我知道问题所在，应该是“ g2.setColor（Color.BLACK）;”之类的东西，但是我要让用户输入颜色，因此它需要是一个变量，我希望除了每种颜色的if语句外，还有其他更干净的东西。

有什么建议么？ 谢谢！

Answer 1

1. 您的Board类包含一个成员变量int[][] board ，但是它的作用域是私有的。 当您致电以下内容：

   colorNum = board [count] [counter];

这是错误的，因为此处的board变量是Board类的对象。 它本身不是两天的数组，但是将int[][] board封装在其中。 因此，您需要在Board提供一个getter方法来公开其board成员变量，如下所示：

public int[][] getBoard() {
  return board;
} 

然后，在paintComponent方法中，您可以通过以下方式访问它： board.getBoard()[count][counter] 。

2. 您似乎已经在colorOfSquare变量中已经有用户输入了颜色。 但是Graphics2D的setColor方法将只接受类型为java.awt.Color的变量。 既然你有颜色的字符串表示，可以提到使用反射得到其相应的价值java.awt.Color中这里 。 以下应该为您工作：

    Color color; try { Field field = Color.class.getField(colorOfSquare); color = (Color) field.get(null); } catch (Exception e) { color = null; // Not defined } 

Answer 2

两个答案：

1. paintComponent 仅接收Graphics对象。 请参阅此链接以获取简短教程。 如果您需要使用此方法访问其他对象，请将它们设置为GraphicalBoard变量，并在构造过程中将其传递给om。

1.5您需要访问董事会的董事会，因为这是您正在使用的。 因此getBoard(int i, int j)在类Board添加一个getBoard(int i, int j) 。 类似于以下内容（我还添加了getSize()方法）：

public int getBoard(int i, int j) {
  return board[i][j] ;
} 

public int getSize() {
   return size;
} 

2. 您的颜色colorOfSquare已定义为一种颜色。 由于Color类没有这样的常数而产生错误。 您应该直接传递颜色。

尝试这个：

  public class GraphicalBoard extends JComponent { 

     private int xSize = 50; 
     private int ySize = 50; 
     private Board board;
     private int size;

      public GraphicalBoard() {
       } 

      public void setBoard(Board board){
         this.board = board;
     } 

      public void paintComponent(Graphics g) { 
        super.paintComponent(); 

        if(board == null) {
          throw new RuntimeException("Board not set") ;
       } 

         String colors[] = {"BLUE","GREEN","YELLOW","RED","BLACK","ORANGE","PINK"}; 
         Graphics2D g2 = (Graphics2D) g; 
         int xCoord = 0; 
         int yCoord = 0; 
         int colorNum = 0; 
         int size = board.getSize() ;
        String colorOfSquare = ""; 

        for (int count = 0; count < size; count++) { 

            for (int counter = 0; counter < size; counter++) { 
               colorNum = board.getBoard(count, counter) ; 
               colorOfSquare = colors[colorNum]; 
               g2.setColor(colorOfSquare); 
               Rectangle square = new Rectangle(xCoord,yCoord,xSize,ySize); 
               xCoord += 50; 
             } 
           yCoord += 50;
         } 
}

Answer 3

总的来说，

1. 您的视图（这里的图形JPanel）应包含通过has-a或“ composition”结构对模型对象的引用
2. 应该经常通过事件侦听器（例如PropertyChangeListener）将模型中的更改通知给视图
3. 然后，视图提取关键信息，并使用该信息来帮助确定要绘制的内容。 因此，如果它具有对当前Board对象的引用，则可以从paintComponent方法内部进行getter方法调用。

您代码中的其他问题：

• 确保在您的覆盖范围内调用上级的paintComponent，否则您将不会清理“脏”像素
• 请勿将线性代码与基于System.in的扫描仪与GUI代码混合使用。 做到这一个或另一个。

---

例如，在下面的代码中，我使用一个模型类，该类包含int [] []板变量，在这里称为BoardModel，并给它一个SwingPropertyChangeSupport对象。

class BoardModel {
    // .....
    private SwingPropertyChangeSupport support = new SwingPropertyChangeSupport(this);

该对象将接受侦听器，并允许我将模型更改通知侦听器。

public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
    support.addPropertyChangeListener(propertyName, listener);
}

然后，当模型更改时，我通过调用支持对象的firePropertyChange(...)方法来通知所有侦听器：

public void selectSquare(int x, int y) {
    int replacementValue = board[y][x];
    int targetValue = board[0][0];
    if (targetValue == replacementValue) {
        return;
    } else {
        recursiveMove(0, 0, targetValue, replacementValue);
        numOfMoves++;
        support.firePropertyChange(BOARD, null, board);  // ***** here
        setWin(checkForWin());
    }
}    

然后在控件中，我可以添加侦听器，以通知更改的视图：

       model.addPropertyChangeListener(BoardModel.BOARD, new PropertyChangeListener() {

            @Override
            public void propertyChange(PropertyChangeEvent e) {
                view.repaint();
                String moveCount = "" + model.getNumOfMoves();
                controlPanel.setMoveCountFieldText(moveCount);
            }
        });
        model.addPropertyChangeListener(BoardModel.WIN, new PropertyChangeListener() {

            @Override
            public void propertyChange(PropertyChangeEvent evt) {
                if ((boolean) evt.getNewValue()) {
                    String message = "Move count: " + model.getNumOfMoves();
                    String title = "Game Over";
                    int messageType = JOptionPane.PLAIN_MESSAGE;
                    JOptionPane.showMessageDialog(view, message, title, messageType);
                }
            }
        });

一个可行的示例如下所示：

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.event.*;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.Random;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;
import javax.swing.event.SwingPropertyChangeSupport;

public class BoardFun {
    private static final int NUM_COLORS = 6;
    private static final int SIZE = 20;

    @SuppressWarnings("serial")
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            int size = SIZE;
            int numColors = NUM_COLORS;
            final BoardModel model = new BoardModel(size , numColors );
            final BoardPanel view = new BoardPanel();
            final ControlPanel controlPanel = new ControlPanel();

            view.setModel(model);
            view.addMouseListener(new MouseAdapter() {
                @Override
                public void mousePressed(MouseEvent mEvt) {
                    Point p = mEvt.getPoint();
                    int row = view.getRow(p);
                    int col = view.getColumn(p);
                    model.selectSquare(col, row);
                }
            });
            model.addPropertyChangeListener(BoardModel.BOARD, new PropertyChangeListener() {

                @Override
                public void propertyChange(PropertyChangeEvent e) {
                    view.repaint();
                    String moveCount = "" + model.getNumOfMoves();
                    controlPanel.setMoveCountFieldText(moveCount);
                }
            });
            model.addPropertyChangeListener(BoardModel.WIN, new PropertyChangeListener() {

                @Override
                public void propertyChange(PropertyChangeEvent evt) {
                    if ((boolean) evt.getNewValue()) {
                        String message = "Move count: " + model.getNumOfMoves();
                        String title = "Game Over";
                        int messageType = JOptionPane.PLAIN_MESSAGE;
                        JOptionPane.showMessageDialog(view, message, title, messageType);
                    }
                }
            });
            controlPanel.setResetAction(new AbstractAction("Reset") {

                @Override
                public void actionPerformed(ActionEvent e) {
                    model.reset();
                }
            });

            JFrame frame = new JFrame("Game");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.add(view);
            frame.add(controlPanel, BorderLayout.PAGE_START);
            frame.pack();
            frame.setLocationRelativeTo(null);
            frame.setVisible(true);
        });
    }
}

@SuppressWarnings("serial")
class ControlPanel extends JPanel {
    private JTextField moveCountField = new JTextField("0", 10);
    private JButton resetButton = new JButton();

    public ControlPanel() {
        add(new JLabel("Move Count:"));
        add(moveCountField);
        add(resetButton);
    }

    public void setResetAction(Action action) {
        resetButton.setAction(action);
    }

    public void setMoveCountFieldText(String text) {
        moveCountField.setText(text);
    }
}

@SuppressWarnings("serial")
class BoardPanel extends JPanel {
    private static final int PREF_W = 640;
    private static final int PREF_H = PREF_W;
    private BoardModel model;
    private Color[] colors;

    @Override
    public Dimension getPreferredSize() {
        if (isPreferredSizeSet()) {
            return super.getPreferredSize();
        } else {
            return new Dimension(PREF_W, PREF_H);
        }
    }

    public void setModel(BoardModel model) {
        this.model = model;
        colors = new Color[model.getNumColors()];

        // create colors.length Colors, all of different hue
        for (int i = 0; i < colors.length; i++) {
            float hue = (float) i / colors.length;
            colors[i] = Color.getHSBColor(hue, 1f, 1f);
        }
    }

    // translate point to logical square position
    int getRow(Point p) {
        return (p.y * model.getBoard().length) / getHeight();
    }

    int getColumn(Point p) {
        return (p.x * model.getBoard()[0].length) / getWidth();
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);  // always call the super's method
        if (model == null) {
            return;
        }
        int board[][] = model.getBoard();
        int height = getHeight() / board.length;
        int width = getWidth() / board[0].length;
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[i].length; j++) {
                Color color = colors[board[i][j]];
                g.setColor(color);
                int x = (j * getWidth()) / board[0].length;
                int y = (i * getHeight()) / board.length;
                g.fillRect(x, y, width, height);
            }
        }
    }
}

class BoardModel {
    public static final String BOARD = "board";
    public static final String WIN = "win";
    private int[][] board;
    private int numColors;
    private Random random = new Random();
    private SwingPropertyChangeSupport support = new SwingPropertyChangeSupport(this);
    private int numOfMoves = 0;
    private boolean win = false;

    public BoardModel(int size, int numColors) {
        board = new int[size][size];
        this.numColors = numColors;
        reset();
    }

    public void reset() {
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[i].length; j++) {
                board[i][j] = random.nextInt(numColors);
            }
        }
        numOfMoves = 0;
        support.firePropertyChange(BOARD, null, board);
        setWin(false);
    }

    public int[][] getBoard() {
        return board;
    }

    public int getNumOfMoves() {
        return numOfMoves;
    }

    public int getNumColors() {
        return numColors;
    }

    public void setWin(boolean win) {
        boolean oldValue = this.win;
        boolean newValue = win;
        this.win = win;
        support.firePropertyChange(WIN, oldValue, newValue);
    }

    public boolean isWin() {
        return win;
    }

    public void selectSquare(int x, int y) {
        int replacementValue = board[y][x];
        int targetValue = board[0][0];
        if (targetValue == replacementValue) {
            return;
        } else {
            recursiveMove(0, 0, targetValue, replacementValue);
            numOfMoves++;
            support.firePropertyChange(BOARD, null, board);
            setWin(checkForWin());
        }
    }



    public boolean checkForWin() {
        int value = board[0][0];
        for (int[] row : board) {
            for (int cell : row) {
                if (cell != value) {
                    return false;
                }
            }
        }
        return true;
    }

    private void recursiveMove(int i, int j, int targetValue, int replacementValue) {
        int currentValue = board[i][j];
        if (currentValue != targetValue || currentValue == replacementValue) {
            return;
        }
        board[i][j] = replacementValue;
        int rowMin = Math.max(0, i - 1);
        int rowMax = Math.min(board.length - 1, i + 1);
        int colMin = Math.max(0, j - 1);
        int colMax = Math.min(board[i].length - 1, j + 1);
        for (int i2 = rowMin; i2 <= rowMax; i2++) {
            if (i2 != i) {
                recursiveMove(i2, j, targetValue, replacementValue);
            }
        }
        for (int j2 = colMin; j2 <= colMax; j2++) {
            if (j2 != j) {
                recursiveMove(i, j2, targetValue, replacementValue);
            }
        }
    }

    public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
        support.addPropertyChangeListener(propertyName, listener);
    }   
}