java - 如何制作一个按钮程序？ ( java )

Question

我有一个关于制作按钮程序的问题。于是，我制作了一些简单的“猜猜游戏”、“贪吃蛇”、“俄罗斯方 block ”等程序和一个按钮程序。我想制作一个程序，当您单击按钮时，它会运行特定的程序。例如，如果您单击“按钮 1”，它将运行“俄罗斯方 block ”。任何帮助都会很棒!

这是“俄罗斯方 block ”程序(代码)。

package tetris;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.ArrayList;
import java.util.Collections;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Tetris extends JPanel
{
    private static final long serialVersionUID = -8715353373678321308L;

    private final Point[][][] Tetraminos = {
            // I-Piece
            {
                {new Point(0, 1), new Point(1, 1), new Point(2, 1), new Point(3, 1)},
                {new Point(1, 0), new Point(1, 1), new Point(1, 2), new Point(1, 3)},
                {new Point(0, 1), new Point(1, 1), new Point(2, 1), new Point(3, 1)},
                {new Point(1, 0), new Point(1, 1), new Point(1, 2), new Point(1, 3)}
            },

            // J-Piece
            {
                {new Point(0, 1), new Point(1, 1), new Point(2, 1), new Point(2, 0)},
                {new Point(1, 0), new Point(1, 1), new Point(1, 2), new Point(2, 2)},
                {new Point(0, 1), new Point(1, 1), new Point(2, 1), new Point(0, 2)},
                {new Point(1, 0), new Point(1, 1), new Point(1, 2), new Point(0, 0)}
            },

            // L-Piece
            {
                {new Point(0, 1), new Point(1, 1), new Point(2, 1), new Point(2, 2)},
                {new Point(1, 0), new Point(1, 1), new Point(1, 2), new Point(0, 2)},
                {new Point(0, 1), new Point(1, 1), new Point(2, 1), new Point(0, 0)},
                {new Point(1, 0), new Point(1, 1), new Point(1, 2), new Point(2, 0)}
            },

            // O-Piece
            {
                {new Point(0, 0), new Point(0, 1), new Point(1, 0), new Point(1, 1)},
                {new Point(0, 0), new Point(0, 1), new Point(1, 0), new Point(1, 1)},
                {new Point(0, 0), new Point(0, 1), new Point(1, 0), new Point(1, 1)},
                {new Point(0, 0), new Point(0, 1), new Point(1, 0), new Point(1, 1)}
            },

            // S-Piece
            {
                {new Point(1, 0), new Point(2, 0), new Point(0, 1), new Point(1, 1)},
                {new Point(0, 0), new Point(0, 1), new Point(1, 1), new Point(1, 2)},
                {new Point(1, 0), new Point(2, 0), new Point(0, 1), new Point(1, 1)},
                {new Point(0, 0), new Point(0, 1), new Point(1, 1), new Point(1, 2)}
            },

            // T-Piece
            {
                {new Point(1, 0), new Point(0, 1), new Point(1, 1), new Point(2, 1)},
                {new Point(1, 0), new Point(0, 1), new Point(1, 1), new Point(1, 2)},
                {new Point(0, 1), new Point(1, 1), new Point(2, 1), new Point(1, 2)},
                {new Point(1, 0), new Point(1, 1), new Point(2, 1), new Point(1, 2)}
            },

            // Z-Piece
            {
                {new Point(0, 0), new Point(1, 0), new Point(1, 1), new Point(2, 1)},
                {new Point(1, 0), new Point(0, 1), new Point(1, 1), new Point(0, 2)},
                {new Point(0, 0), new Point(1, 0), new Point(1, 1), new Point(2, 1)},
                {new Point(1, 0), new Point(0, 1), new Point(1, 1), new Point(0, 2)}
            }
    };

    private final Color[] tetraminoColors = {
        Color.cyan, Color.blue, Color.orange, Color.yellow, Color.green, Color.pink, Color.red
    };

    private Point pieceOrigin;
    private int currentPiece;
    private int rotation;
    private ArrayList<Integer> nextPieces = new ArrayList<Integer>();

    private long score;
    private Color[][] well;

    // Creates a border around the well and initializes the dropping piece
    private void init()
    {
        well = new Color[12][24];
        for (int i = 0; i < 12; i++)
        {
            for (int j = 0; j < 23; j++)
            {
                if (i == 0 || i == 11 || j == 22)
                {
                    well[i][j] = Color.GRAY;
                }
                else
                {
                    well[i][j] = Color.BLACK;
                }
            }
        }
        newPiece();
    }

    // Put a new, random piece into the dropping position
    public void newPiece()
    {
        pieceOrigin = new Point(5, 2);
        rotation = 0;

        if (nextPieces.isEmpty())
        {
            Collections.addAll(nextPieces, 0, 1, 2, 3, 4, 5, 6);
            Collections.shuffle(nextPieces);
        }
        currentPiece = nextPieces.get(0);
        nextPieces.remove(0);
    }

    // Collision test for the dropping piece
    private boolean collidesAt (int x, int y, int rotation)
    {
        for (Point p : Tetraminos[currentPiece][rotation])
        {
            if (well[p.x + x][p.y + y] != Color.BLACK)
            {
                return true;
            }
        }

        return false;
    }

    // Rotate the piece clockwise or counterclockwise
    public void rotate (int i)
    {
        int newRotation = (rotation + i) % 4;

        if (newRotation < 0)
        {
            newRotation = 3;
        }
        if (!collidesAt(pieceOrigin.x, pieceOrigin.y, newRotation))
        {
            rotation = newRotation;
        }
        repaint();
    }

    // Move the piece left or right
    public void move (int i)
    {
        if (!collidesAt(pieceOrigin.x + i, pieceOrigin.y, rotation))
        {
            pieceOrigin.x += i; 
        }
        repaint();
    }

    // Drops the piece one line or fixes it to the well if it can't drop
    public void dropDown() {
        if (!collidesAt(pieceOrigin.x, pieceOrigin.y + 1, rotation)) {
            pieceOrigin.y += 1;
        } else {
            fixToWell();
        }   
        repaint();
    }

    // Make the dropping piece part of the well, so it is available for
    // collision detection.
    public void fixToWell()
    {
        for (Point p : Tetraminos[currentPiece][rotation])
        {
            well[pieceOrigin.x + p.x][pieceOrigin.y + p.y] = tetraminoColors[currentPiece];
        }
        clearRows();
        newPiece();
    }

    public void deleteRow (int row)
    {
        for (int j = row-1; j > 0; j--)
        {
            for (int i = 1; i < 11; i++)
            {
                well[i][j+1] = well[i][j];
            }
        }
    }

    // Clear completed rows from the field and award score according to
    // the number of simultaneously cleared rows.
    public void clearRows()
    {
        boolean gap;
        int numClears = 0;

        for (int j = 21; j > 0; j--)
        {
            gap = false;

            for (int i = 1; i < 11; i++)
            {
                if (well[i][j] == Color.BLACK)
                {
                    gap = true;
                    break;
                }
            }
            if (!gap)
            {
                deleteRow(j);
                j += 1;
                numClears += 1;
            }
        }

        switch (numClears)
        {
            case 1: score += 100;
            break;
            case 2: score += 300;
            break;
            case 3: score += 500;
            break;
            case 4: score += 800;
            break;
        }
    }

    // Draw the falling piece
    private void drawPiece (Graphics g)
    {       
        g.setColor(tetraminoColors[currentPiece]);
        for (Point p : Tetraminos[currentPiece][rotation])
        {
            g.fillRect((p.x + pieceOrigin.x) * 26, (p.y + pieceOrigin.y) * 26, 25, 25);
        }
    }

    @Override 
    public void paintComponent (Graphics g)
    {
        // Paint the well
        g.fillRect(0, 0, 26 * 12, 26 * 23);
        for (int i = 0; i < 12; i++)
        {
            for (int j = 0; j < 23; j++)
            {
                g.setColor(well[i][j]);
                g.fillRect(26 * i, 26 * j, 25, 25);
            }
        }

        // Display the score
        g.setColor(Color.WHITE);
        g.drawString("" + score, 19 * 12, 25);

        // Draw the currently falling piece
        drawPiece(g);
    }

    public static void main(String[] args)
    {
        JFrame f = new JFrame("Tetris");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setSize(12*26+10, 26*23+25);
        f.setVisible(true);

        final Tetris game = new Tetris();
        game.init();
        f.add(game);

        // Keyboard controls
        f.addKeyListener(new KeyListener()
        {
            public void keyTyped(KeyEvent e)
            {
            }

            public void keyPressed(KeyEvent e)
            {
                switch (e.getKeyCode())
                {
                    case KeyEvent.VK_UP: game.rotate(-1);
                    break;
                    case KeyEvent.VK_DOWN: game.rotate(+1);
                    break;
                    case KeyEvent.VK_LEFT: game.move(-1);
                    break;
                    case KeyEvent.VK_RIGHT: game.move(+1);
                    break;
                    case KeyEvent.VK_SPACE: game.dropDown();
                    game.score += 1;
                    break;
                } 
            }

            public void keyReleased (KeyEvent e)
            {
            }
        });

        // Make the falling piece drop every second
        new Thread()
        {
            @Override
            public void run()
            {
                while (true)
                {
                    try
                    {
                        Thread.sleep(1000);
                        game.dropDown();
                    }
                    catch ( InterruptedException e )
                    {
                    }
                }
            }
        }.start();
    }
}

这是“猜谜游戏”程序(代码)。

package guessinggame;
import java.util.Scanner;

public class GuessingGame
{
    private int upperBound;

    public GuessingGame(int stop)
    {
        upperBound = stop;
    }

    public void playGame()
    {
        Scanner keyboard = new Scanner(System.in);
        int num = (int)(Math.random() * upperBound) + 1;
        int guesses = 0;
        System.out.print("Enter a number between 1 - " + upperBound + ": ");

        int i = 0;
        do
        {
            i = keyboard.nextInt();

            if (i > num)
            {
                System.out.print("Too high. Try another number. :: ");
            }
            if (i < num)
            {
                System.out.print("Too low. Try another number. :: ");
            }

            guesses++;
        }
        while (i != num);

        System.out.println("Correct!");

        double percentage;
        percentage = (double)(guesses) / upperBound;
        int percen = (int)(percentage * 100);
        System.out.println("It took " + guesses + " guesses to guess the number " + num + ".\n" +
                           "You guessed " + percen + "% of the possible values.");
    }
}






package guessinggame;
import java.util.Scanner;

public class GuessingGameRunner
{
    public static void main(String args[])
    {
        Scanner keyboard = new Scanner(System.in);
        String response;

        int top;
        do
        {
            System.out.print("Guessing Game. Range of highest number? :: ");
            top = keyboard.nextInt();
            GuessingGame run = new GuessingGame(top);
            run.playGame();
            System.out.print("Do you want to play again? (y, n) :: ");
            response = keyboard.next();
        }
        while (response.equals("y"));
    }
}

这是按钮程序(代码)。

package button;
import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.Color;
import java.awt.Frame;
import java.awt.GridLayout;
import java.awt.Label;
import java.awt.Panel;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class Buttons extends Frame
{
    public Buttons()
    {
        super("");
        this.setLayout(new BorderLayout());
        //this.add("North", new Label("North", Label.LEFT));

        Panel centerPanel = new Panel(new GridLayout(2, 2, 5, 5));
        centerPanel.add(new Button("Button 0"));
        centerPanel.add(new Button("Button 1"));
        centerPanel.add(new Button("Button 2"));
        centerPanel.add(new Button("Button 3"));

        this.add("Center", centerPanel);
        Panel southPanel = new Panel(new GridLayout(1, 2));
        //Label test = new Label("Test");
        //test.setBackground(Color.YELLOW);
        //southPanel.add(test);
        Panel panel = new Panel(new GridLayout(2, 1));
        Label test1 = new Label("Test1");
        test1.setBackground(Color.RED);
        Label test2 = new Label("Test2");
        test2.setBackground(Color.GREEN);
        panel.add(test1);
        panel.add(test2);
        //southPanel.add("South", southPanel);
        this.add("South", southPanel);
        this.addWindowListener(new WindowAdapter()
        {
             public void windowClosing(WindowEvent e)
             {
                System.exit(0);
             }
        });

        this.setSize(400,  200);
        this.setVisible(true);
    }

    public static void main(String[] args)
    {
        new Buttons();
    }
}

所以我希望在单击“按钮 0”时运行第一个程序，在单击“按钮 1”时运行第二个程序。顺便说一句，我正在使用 Eclipse。

谢谢!!!

Answer 1

由于每个游戏类都有其自己的 main 方法，因此您只需使用要启动的游戏的相应 main 方法即可。

由于main方法是静态的不需要任何初始化，只需 -

GuessingGame.main();

或

Tetris.main();