How do I access variables from a different class

Question

I have three classes and am trying to run my program. I need to access variables from another class. I have already tried to make the variables public but this still does not seem to work.The variables giving me the error are located in the TetrisPiece class. The variables are: PIECE_BITS,COLUMNS,ROWS,EMPTY and grid. How do I access these variables?

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 (class with the errors)

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);
    }
}

Answer 1

The answer from @Eran is correct, but if you do not want to change your code, you can also use static import

add the following in your import statement

import static Tetris.PIECE_BITS;
import static Tetris.COLUMNS;
import static Tetris.ROWS;
import static Tetris.EMPTY;

Grid variable is not static so you cannot use the same

its defined as

public int grid[][] = new int[ROWS][COLUMNS];

you will need to define a getter :

public int[][] getGrid () {
    return grid;
}

and call the getGrid() method to access the variable value.

Answer 2

Those variables are declared in the Tetris class, and they are static, so in order to access them from another class qualify them with the class name.

For example, in the TetrisPiece constructor :

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];
}