我有三个课程，我正在尝试运行我的程序。我需要从另一个类访问变量。我已经尝试将变量公开但这似乎仍然不起作用。给我错误的变量位于TetrisPiece类中。变量是：PIECE_BITS，COLUMNS，ROWS，EMPTY和grid。如何访问这些变量？
Tetris.java
import java.awt.*;
import java.applet.*;
import java.awt.event.*;
import java.util.Random;
import static java.awt.Color.*;
public class Tetris extends Applet {
//
// STATIC MEMBERS
//
private final static int INITIAL_DELAY = 1000;
private final static int EMPTY = -1;
private final static int DELETED_ROWS_PER_LEVEL = 5;
public final static byte ROWS = 20;
public final static byte COLUMNS = 10;
static Color[] colors =
{black, green, blue, red,
yellow, magenta, pink, cyan};
public int total_score;
private final static Color BACKGROUND_COLOR = Color.black;
public final static boolean PIECE_BITS[][][] = {
{
{false, true, false, false},
{false, true, false, false},
{false, true, false, false},
{false, true, false, false},
},
{
{false, false, false, false},
{false, true, true, false},
{false, true, false, false},
{false, true, false, false},
},
{
{false, false, false, false},
{false, true, false, false},
{false, true, false, false},
{false, true, true, false},
},
{
{false, false, false, false},
{false, true, false, false},
{false, true, true, false},
{false, false, true, false},
},
{
{false, false, false, false},
{false, false, true, false},
{false, true, true, false},
{false, true, false, false},
},
{
{false, false, false, false},
{false, true, false, false},
{false, true, true, false},
{false, true, false, false},
},
{
{false, false, false, false},
{false, false, false, false},
{false, true, true, false},
{false, true, true, false},
},
};
private static Random random = new Random();
//
// INSTANCE DATA
//
public int grid[][] = new int[ROWS][COLUMNS];
private int next_piece_grid[][] = new int[4][4];
private int num_rows_deleted = 0;
private GridCanvas game_grid = new GridCanvas(grid, true);
private GridCanvas next_piece_canvas = new GridCanvas(next_piece_grid, false);
private Timer timer;
private TetrisPiece cur_piece;
private TetrisPiece next_piece = randomPiece();
//
// INNER CLASSES
//
private class Timer extends Thread {
private long m_delay;
private boolean m_paused = true;
private boolean m_fast = false;
private ActionListener m_cb;
public Timer(long delay, ActionListener cb) {
setDelay(delay);
m_cb = cb;
}
public void setPaused(boolean pause) {
m_paused = pause;
if (m_paused) {
} else {
synchronized (this) {
this.notify();
}
}
}
public void setDelay(long delay) {
m_delay = delay;
}
public void setFast(boolean fast) {
m_fast = fast;
if (m_fast) {
try {
this.checkAccess();
this.interrupt(); // no exception, so OK to interrupt
} catch (SecurityException se) {
}
}
}
public void faster() {
m_delay = (int) (m_delay * .9); //increase the speed exponentially in reverse
}
public void run() {
while (true) {
try {
sleep(m_fast ? 30 : m_delay);
} catch (Exception e) {
}
if (m_paused) {
try {
synchronized (this) {
this.wait();
}
} catch (InterruptedException ie) {
}
}
synchronized (this) {
m_cb.actionPerformed(null);
}
}
}
} // end class Timer
private class GridCanvas extends DoubleBufferedCanvas {
private int grid[][];
public GridCanvas(int[][] grid, boolean do_background) {
this.grid = grid;
clear();
}
private void clear() {
for (int i = 0; i < grid.length; i++)
for (int j = 0; j < grid[0].length; j++)
grid[i][j] = EMPTY;
}
public Dimension getPreferredSize() {
return new Dimension(grid[0].length * 30, grid.length * 30);
}
public void paint(Graphics g) {
g = this.startPaint(g); // returned g paints into offscreen image
int width = this.getSize().width;
int height = this.getSize().height;
g.clearRect(0, 0, width, height);
int cell_size, xstart, ystart;
double panel_aspect_ratio = (double) width / height;
double grid_aspect_ratio = (double) grid[0].length / grid.length;
if (panel_aspect_ratio > grid_aspect_ratio) {
// extra space on sides
cell_size = (int) ((double) height / grid.length + 0.5);
xstart = (int) (width / 2 - (grid[0].length / 2.0 * cell_size + 0.5));
ystart = 0;
} else {
// extra vertical space
cell_size = (int) ((double) width / grid[0].length + 0.5);
xstart = 0;
ystart = (int) (height / 2 - (grid.length / 2.0 * cell_size + 0.5));
}
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[0].length; j++) {
if (grid[i][j] != EMPTY) {
g.setColor(colors[grid[i][j]]);
int x = xstart + j * cell_size;
int y = ystart + i * cell_size;
g.fill3DRect(x, y, cell_size, cell_size, true);
}
}
}
this.endPaint(); // paints accumulated image in one shot
}
}
private TetrisPiece randomPiece() {
int rand = Math.abs(random.nextInt());
return new TetrisPiece(rand % (colors.length));
}
private void installNewPiece() {
next_piece_canvas.clear();
cur_piece = next_piece;
cur_piece.setPosition(3, -4); //-4 to start above top of grid
if (cur_piece.canPaste()) {
next_piece = randomPiece();
next_piece.setPosition(0, 0);
next_piece.paste(next_piece_grid);
next_piece_canvas.repaint();
} else
gameOver();
}
private void gameOver() {
System.out.println("Game Over!");
timer.setPaused(true);
}
private boolean rowIsFull(int row) {
for (int i = 0; i < COLUMNS; i++)
if (grid[row][i] == EMPTY)
return false;
return true;
}
private int countFullRows() {
int n_full_rows = 0;
for (int i = 0; i < ROWS; i++)
if (rowIsFull(i))
n_full_rows++;
return n_full_rows;
}
private void removeRow(int row) {
for (int j = 0; j < COLUMNS; j++)
grid[row][j] = EMPTY;
for (int i = row; i > 0; i--) {
for (int j = 0; j < COLUMNS; j++) {
grid[i][j] = grid[i - 1][j];
}
}
}
private void removeFullRows() {
int n_full = countFullRows();
total_score = total_score + 10;
if (n_full == 0)
return;
if (num_rows_deleted / DELETED_ROWS_PER_LEVEL != (num_rows_deleted + n_full) / DELETED_ROWS_PER_LEVEL) {
timer.faster();
}
num_rows_deleted += n_full;
for (int i = ROWS - 1; i >= 0; i--)
while (rowIsFull(i))
removeRow(i);
game_grid.repaint();
}
public void start() {
timer = new Timer(INITIAL_DELAY, new ActionListener() {
public void actionPerformed(ActionEvent ae) {
synchronized (timer) {
if (cur_piece.canStepDown()) {
cur_piece.cut();
cur_piece.stepDown();
cur_piece.paste();
} else { // it hit something
timer.setFast(false);
if (!cur_piece.isTotallyOnGrid())
gameOver();
else {
removeFullRows();
installNewPiece();
}
}
}
game_grid.repaint();
}
});
timer.start();
}
public void stop() {
pauseGame();
synchronized (timer) {
timer.stop();
}
timer = null;
}
public void startGame() {
timer.setDelay(INITIAL_DELAY);
timer.setPaused(false);
}
private void pauseGame() {
timer.setPaused(true);
}
public void init() {
installNewPiece();
//create key listener for moving left, moving right
class TAdapter extends KeyAdapter {
public void keyPressed(KeyEvent e) {
int keycode = e.getKeyCode();
switch (keycode) {
case KeyEvent.VK_LEFT:
if (e.getKeyCode() == 37 || e.getKeyCode() == 38) {
int dir = e.getKeyCode() == 37 ? -1 : 1;
synchronized (timer) {
cur_piece.cut();
cur_piece.setX(cur_piece.getX() + dir);
if (!cur_piece.canPaste()) {
cur_piece.setX(cur_piece.getX() - dir);
}
}
}
}
}
}
//setting background colour and Tetrus grid
this.setLayout(new GridLayout(1, 2));
this.add(game_grid);
this.setBackground(BACKGROUND_COLOR);
this.validate();
}
class DoubleBufferedCanvas extends Canvas {
private Image mActiveOffscreenImage = null;
private Dimension mOffscreenSize = new Dimension(-1, -1);
private Graphics mActiveOffscreenGraphics = null;
private Graphics mSystemGraphics = null;
DoubleBufferedCanvas() {
}
public void update(Graphics g) {
paint(g);
}
public Graphics startPaint(Graphics sysgraph) {
mSystemGraphics = sysgraph;
Dimension d = getSize();
if ((mActiveOffscreenImage == null) ||
(d.width != mOffscreenSize.width) ||
(d.height != mOffscreenSize.height)) {
mActiveOffscreenImage = createImage(d.width, d.height);
mActiveOffscreenGraphics = mActiveOffscreenImage.getGraphics();
mOffscreenSize = d;
mActiveOffscreenGraphics.setFont(getFont());
}
return mActiveOffscreenGraphics;
}
public void endPaint() {
mSystemGraphics.drawImage(mActiveOffscreenImage, 0, 0, null);
}
}
}
TetrisPiece.java （有错误的课程）
import java.awt.*;
public class TetrisPiece {
private boolean squares[][];
private int type;
private Point position = new Point(3, -4); // -4 to start above top row
public int getX() { return position.x; }
public int getY() { return position.y; }
public void setX(int newx) { position.x = newx; }
public void setY(int newy) { position.y = newy; }
public void setPosition(int newx, int newy) { setX(newx); setY(newy);
}
public TetrisPiece(int type) {
this.type = type;
this.squares = new boolean[4][4];
for(int i=0; i<4; i++)
for(int j=0; j<4; j++)
this.squares[i][j] = PIECE_BITS[type][i][j];
}
public boolean canStepDown() {
synchronized(timer) {
cut();
position.y++;
boolean OK = canPaste();
position.y--;
paste();
return OK;
}
}
public boolean canPaste() {
for(int i=0; i<4; i++) {
for(int j=0; j<4; j++) {
int to_x = j + position.x;
int to_y = i + position.y;
if(squares[i][j]) {
//checks if sqaure is too far left or right
if(0 > to_x || to_x >= COLUMNS
|| to_y >= ROWS) // square off bottom?
{
return false;
// This allows the user to move a piece before it drops
// completely into view.
}
if(to_y >= 0 && grid[to_y][to_x] != EMPTY)
return false;
}
}
}
return true;
}
public void stepDown() {
position.y++;
}
public void cut() {
for(int i=0; i<4; i++)
for(int j=0; j<4; j++)
if(squares[i][j] && position.y+i>=0)
grid[position.y + i][position.x + j] = EMPTY;
}
/**
* Paste the color info of this piece into the given grid
*/
public void paste(int into[][]) {
for(int i=0; i<4; i++)
for(int j=0; j<4; j++)
if(squares[i][j] && position.y+i>=0)
into[position.y + i][position.x + j] = type;
}
/**
* No argument version assumes pasting into main game grid
*/
public void paste() {
paste(grid);
}
// this method is a bit of a hack to check for the case
// where a piece may be safely on the grid but have one or more
// rows of empty squares that are above the grid and therefore OK
public boolean isTotallyOnGrid() {
for(int i=0; i<4; i++) {
if(position.y + i >= 0)
return true; //everything from here down is on grid
// this row is above grid so look for non-empty squares
for(int j=0; j<4; j++)
if(squares[i][j])
return false;
}
System.err.println("TetrisPiece.isTotallyOnGrid internal error");
return false;
}
}
TetrisMain
import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
public class TetrisMain {
public static void main(String[] args) {
Frame frame = new Frame("Tetris");
Tetris tetris = new Tetris();
frame.add(tetris);
tetris.init();
tetris.start();
tetris.startGame();
frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
frame.setSize(250,500);
frame.setResizable(false);
frame.setVisible(true);
}
}
答案 0 :(得分：2)
这些变量在Tetris类中声明，并且它们是静态的，因此为了从另一个类访问它们，使用类名限定它们。
例如，在TetrisPiece构造函数中：
public TetrisPiece(int type) {
this.type = type;
this.squares = new boolean[4][4];
for(int i=0; i<4; i++)
for(int j=0; j<4; j++)
this.squares[i][j] = Tetris.PIECE_BITS[type][i][j];
}
答案 1 :(得分：2)
@Eran的答案是正确的，但如果您不想更改代码，也可以使用static import
在导入语句中添加以下内容
import static Tetris.PIECE_BITS;
import static Tetris.COLUMNS;
import static Tetris.ROWS;
import static Tetris.EMPTY;
Grid变量不是静态的，因此您不能使用相同的
定义为
public int grid[][] = new int[ROWS][COLUMNS];
您需要定义一个getter：
public int[][] getGrid () {
return grid;
}
并调用getGrid()方法来访问变量值。