java - 无法在 JPanel 上移动 JLabel-6ren

java - 无法在 JPanel 上移动 JLabel

转载作者：行者123 更新时间：2023-12-01 16:55:17

好的，所以我正在制作一个垄断游戏。到目前为止，我有一个 JFrame，其中有一个 JPanel 作为板。我已经加载了所有必要的图像。我创建了一个扩展 JLabel 的 Player 对象，以代表棋盘上的玩家。

我正在尝试设置(希望在棋盘上移动棋子)Player 对象(这是一个 JLabel)在棋盘上(这是JPanel)。我尝试了 .setLocation 方法、.setBounds 方法。

出于某种原因，无论我做什么，Player 对象都只显示在 JPanel 的顶部中间。我想知道如何移动板上的 Player 对象。

JFrame 代码(我尝试移动构造函数底部的 JLabel):

   package com.Game.Monopoly;

    import javax.imageio.ImageIO;
    import javax.swing.ImageIcon;
    import javax.swing.JButton;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.JList;
    import javax.swing.JPanel;
    import javax.swing.JScrollPane;
    import javax.swing.JTextArea;
    import javax.swing.Timer;

    import java.awt.Color;
    import java.awt.Dimension;
    import java.awt.Graphics;
    import java.awt.Image;
    import java.awt.LayoutManager;
    import java.awt.Point;
    import java.awt.SystemColor;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.awt.image.BufferedImage;
    import java.io.IOException;

    import net.miginfocom.swing.MigLayout;

    //a class that represent the board (JFrame) and all of it components 
    public class GameFrame extends JFrame {
        private final double SCALE;
        // all the graphical components
        private Board board;
        private JLabel lblPlayerMoney;
        private JLabel lblCurrentPlayer;
        private JLabel lblDice1;
        private JLabel lblDice2;
        private JList lstPropertiesList;
        private JButton btnEndTurn;
        private JButton btnBuyProperty;
        private JButton btnRollDice;

        // all images needed
        private ImageIcon imgDice1;
        private ImageIcon imgDice2;
        private ImageIcon imgDice3;
        private ImageIcon imgDice4;
        private ImageIcon imgDice5;
        private ImageIcon imgDice6;
        private ImageIcon icnAirplane;

        // all players
        private Player[] playerList;
        // all properties
        private Property[] propertiesList;

        public GameFrame(double scale) {
            // SCALE = scale;
            SCALE = 1;

            // set up the JFrame
            setResizable(true);
            setTitle("Monopoly");
            // etUndecorated(true);
            // set size to a scale of 1080p
            setSize((int) (1920 * SCALE), (int) (1080 * SCALE));
            setLayout(new MigLayout());
            loadImages();

            // add the components to the frame
            board = new Board(SCALE);
            board.setPreferredSize(new Dimension((int) (1024 * SCALE),
                    (int) (1024 * SCALE)));
            board.setBackground(Color.BLACK);
            add(board, "east, gapbefore 80");
            lblCurrentPlayer = new JLabel("Current Player:" + " Player 1");
            add(lblCurrentPlayer, "wrap");
            lblPlayerMoney = new JLabel("Player1's money:" + "$14000000");
            add(lblPlayerMoney, "wrap");
            lstPropertiesList = new JList();
            add(new JScrollPane(lstPropertiesList),
                    "span 2 2, grow, height 70:120:200");
            btnRollDice = new JButton("Roll Dice");
            add(btnRollDice, "wrap");
            lblDice1 = new JLabel(imgDice1);
            add(lblDice1);
            lblDice2 = new JLabel(imgDice1);
            add(lblDice2, "wrap");
            btnBuyProperty = new JButton("Buy Property");
            add(btnBuyProperty, "wrap, top");
            btnEndTurn = new JButton("End Turn");
            add(btnEndTurn, "aligny bottom");

            setUpEventListeners();
            loadProperties();

            // load players
            playerList = new Player[6];
            playerList[0] = new Player("Player 1", icnAirplane);

            // add Players to the board

            board.add(playerList[0]);
            playerList[0].setLocation(new Point(500, 230));
        }

        public static void main(String[] args) {
            GameFrame board = new GameFrame(1);
            board.setVisible(true);

        }

        // method to add event listeners
        public void setUpEventListeners() {

            // roll dice
            btnRollDice.addActionListener(new ActionListener() {
                // creates an object with an timers to help with rolling dice
                class RollDice implements ActionListener {
                    private Timer time = new Timer(152, this);
                    private int count = 0;

                    public void actionPerformed(ActionEvent e) {
                        count++;
                        if (count == 21)
                            time.stop();

                        int whatDice1 = (int) (Math.random() * 6) + 1;
                        int whatDice2 = (int) (Math.random() * 6) + 1;

                        // set the icons of the labels according to the random
                        // number

                        if (whatDice1 == 1)
                            lblDice1.setIcon(imgDice1);
                        else if (whatDice1 == 2)
                            lblDice1.setIcon(imgDice2);
                        else if (whatDice1 == 3)
                            lblDice1.setIcon(imgDice3);
                        else if (whatDice1 == 4)
                            lblDice1.setIcon(imgDice4);
                        else if (whatDice1 == 5)
                            lblDice1.setIcon(imgDice5);
                        else if (whatDice1 == 6)
                            lblDice1.setIcon(imgDice6);

                        if (whatDice2 == 1)
                            lblDice2.setIcon(imgDice1);
                        else if (whatDice2 == 2)
                            lblDice2.setIcon(imgDice2);
                        else if (whatDice2 == 3)
                            lblDice2.setIcon(imgDice3);
                        else if (whatDice2 == 4)
                            lblDice2.setIcon(imgDice4);
                        else if (whatDice2 == 5)
                            lblDice2.setIcon(imgDice5);
                        else if (whatDice2 == 6)
                            lblDice2.setIcon(imgDice6);
                    }

                    public void roll() {
                        count = 0;
                        time.start();
                    }
                }

                // create a new dice roll object
                RollDice roll = new RollDice();

                // if the roll dice button is clicked
                public void actionPerformed(ActionEvent arg0) {
                    roll.roll();
                }

            });

        }

        // load all images to memory
        public void loadImages() {
            BufferedImage i = null;
            try {
                i = ImageIO.read((getClass().getResource("/resources/Dice 1.png")));
                imgDice1 = new ImageIcon(i.getScaledInstance(100, 100,
                        java.awt.Image.SCALE_SMOOTH));

                i = ImageIO.read((getClass().getResource("/resources/Dice 2.png")));
                imgDice2 = new ImageIcon(i.getScaledInstance(100, 100,
                        java.awt.Image.SCALE_SMOOTH));

                i = ImageIO.read((getClass().getResource("/resources/Dice 3.png")));
                imgDice3 = new ImageIcon(i.getScaledInstance(100, 100,
                        java.awt.Image.SCALE_SMOOTH));

                i = ImageIO.read((getClass().getResource("/resources/Dice 4.png")));
                imgDice4 = new ImageIcon(i.getScaledInstance(100, 100,
                        java.awt.Image.SCALE_SMOOTH));

                i = ImageIO.read((getClass().getResource("/resources/Dice 5.png")));
                imgDice5 = new ImageIcon(i.getScaledInstance(100, 100,
                        java.awt.Image.SCALE_SMOOTH));

                i = ImageIO.read((getClass().getResource("/resources/Dice 6.png")));
                imgDice6 = new ImageIcon(i.getScaledInstance(100, 100,
                        java.awt.Image.SCALE_SMOOTH));

                i = ImageIO.read((getClass()
                        .getResource("/resources/Airplane Icon.png")));
                icnAirplane = new ImageIcon(i.getScaledInstance(40, 40,
                        java.awt.Image.SCALE_SMOOTH));

            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }

        // load all properties
        public void loadProperties() {
            propertiesList = new Property[40];

            // set up the properties list
            // (name, index, isBuyable, price, initial rent)
            propertiesList[0] = new Property("Go", 0, false, 0, 0);
            propertiesList[1] = new Property("Jacob's Field", 1, true, 600000,
                    20000);
            propertiesList[2] = new Property("Community Chest", 2, false, 0, 0);
            propertiesList[3] = new Property("Texas Stadium", 3, true, 600000,
                    40000);
            propertiesList[4] = new Property("Income Tax", 4, false, 0, 0);
            propertiesList[5] = new Property("O'Hare International Airport", 5,
                    true, 2000000, 250000);
            propertiesList[6] = new Property("Grand Ole Opry", 6, true, 1000000,
                    60000);
            propertiesList[7] = new Property("Chance", 7, false, 0, 0);

        }
    }

JPanel 代码:

package com.Game.Monopoly;

import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.net.URL;

import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JPanel;

public class Board extends JPanel {
    private static final long serialVersionUID = 1L;
    private Image board;

    public Board(double scale) {
        this.setPreferredSize(new Dimension((int) (1024 * scale),
                (int) (1024 * scale)));

        BufferedImage i = null;
        try {
            i = ImageIO.read((getClass().getResource("/resources/monopoly-board-web.jpg")));

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        board = i.getScaledInstance((int) (1024 * scale), (int) (1024 * scale), java.awt.Image.SCALE_SMOOTH);

    }

    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        g.drawImage(board, 0, 0, this);
    }

}

玩家对象代码:

package com.Game.Monopoly;

import javax.swing.ImageIcon;
import javax.swing.JLabel;

//a class representing a player with its graphical component 
public class Player extends JLabel {

    private String playerName;
    private int money;
    private Property[] propertiesOwned;

    public Player(String n, ImageIcon icon) {
        playerName = n;
        this.setIcon(icon);
    }

    // changes the amount of money available 
    public void changeMoney(int amount) {
        money = money + amount;
    }

    public void movePlayer(int x, int y){ 
        this.setLocation(x, y);
    }

}

最佳答案

有几种方法可以实现这一点，就个人而言，最简单的方法是直接使用自定义绘画，而不必为播放器使用基于 Swing 的组件。

您遇到的基本问题是 JPanel 默认情况下使用 FlowLayout，这意味着您将始终与布局管理器作斗争。在这种情况下，您可能会考虑使用自定义布局管理器，例如...

import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.LayoutManager2;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class Monopoly {

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

    public Monopoly() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                    ex.printStackTrace();
                }

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.add(new MonopolyBoard());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class MonopolyBoard extends JPanel {

        private List<JLabel> players;

        public MonopolyBoard() {
            setLayout(new MonopolyBoardLayout());

            players = new ArrayList<>(2);
            try {
                players.add(makePlayer("/Dog.png"));
                players.add(makePlayer("/Car.png"));

                for (JLabel player : players) {
                    add(player, new Integer(0));
                }
            } catch (IOException exp) {
                exp.printStackTrace();
            }

            Timer timer = new Timer(1000, new ActionListener() {
                private int count = 0;
                private Random rnd = new Random();

                @Override
                public void actionPerformed(ActionEvent e) {
                    int playerIndex = count % players.size();
                    JLabel player = players.get(playerIndex);

                    MonopolyBoardLayout layout = (MonopolyBoardLayout) getLayout();
                    int position = layout.getPosition(player);

                    position += rnd.nextInt(5) + 1;
                    if (position > 35) {
                        position -= 35;
                    }

                    layout.setPosition(player, position);

                    revalidate();
                    repaint();
                    count++;
                }
            });
            timer.start();
        }

        protected JLabel makePlayer(String path) throws IOException {
            JLabel label = new JLabel(new ImageIcon(ImageIO.read(getClass().getResource(path))), JLabel.CENTER);
            return label;
        }

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();
            int width = getWidth();
            int height = getHeight();

            for (int index = 0; index < 36; index++) {
                Rectangle bounds = MonopolyBoardLayoutHelper.getCellBounds(index, width, height);
                g2d.draw(bounds);
            }

            g2d.dispose();
        }

    }

    public static class MonopolyBoardLayoutHelper {

        private static Map<Integer, Point> mapBoardCells;

        static {
            mapBoardCells = new HashMap<>(25);

            mapBoardCells.put(10, new Point(0, 8));
            mapBoardCells.put(11, new Point(0, 7));
            mapBoardCells.put(12, new Point(0, 6));
            mapBoardCells.put(13, new Point(0, 5));
            mapBoardCells.put(14, new Point(0, 4));
            mapBoardCells.put(15, new Point(0, 3));
            mapBoardCells.put(16, new Point(0, 2));
            mapBoardCells.put(17, new Point(0, 1));
            mapBoardCells.put(18, new Point(0, 0));

            mapBoardCells.put(0, new Point(9, 9));
            mapBoardCells.put(1, new Point(8, 9));
            mapBoardCells.put(2, new Point(7, 9));
            mapBoardCells.put(3, new Point(6, 9));
            mapBoardCells.put(4, new Point(5, 9));
            mapBoardCells.put(5, new Point(4, 9));
            mapBoardCells.put(6, new Point(3, 9));
            mapBoardCells.put(7, new Point(2, 9));
            mapBoardCells.put(8, new Point(1, 9));
            mapBoardCells.put(9, new Point(0, 9));

            mapBoardCells.put(19, new Point(1, 0));
            mapBoardCells.put(20, new Point(2, 0));
            mapBoardCells.put(21, new Point(3, 0));
            mapBoardCells.put(22, new Point(4, 0));
            mapBoardCells.put(23, new Point(5, 0));
            mapBoardCells.put(24, new Point(6, 0));
            mapBoardCells.put(25, new Point(7, 0));
            mapBoardCells.put(26, new Point(8, 0));
            mapBoardCells.put(27, new Point(9, 0));

            mapBoardCells.put(28, new Point(9, 1));
            mapBoardCells.put(29, new Point(9, 2));
            mapBoardCells.put(30, new Point(9, 3));
            mapBoardCells.put(31, new Point(9, 4));
            mapBoardCells.put(32, new Point(9, 5));
            mapBoardCells.put(33, new Point(9, 6));
            mapBoardCells.put(34, new Point(9, 7));
            mapBoardCells.put(35, new Point(9, 8));

        }

        public static Rectangle getCellBounds(int index, int width, int height) {
            Rectangle bounds = new Rectangle(0, 0, 0, 0);
            int size = Math.min(width, height);
            int cellSize = size / 10;

            int xOffset = (width - size) / 2;
            int yOffset = (height - size) / 2;

            Point point = mapBoardCells.get(index);
            if (point != null) {

                int x = xOffset + (point.x * cellSize);
                int y = yOffset + (point.y * cellSize);
                bounds = new Rectangle(x, y, cellSize, cellSize);

            }

            return bounds;

        }

    }

    public static class MonopolyBoardLayout implements LayoutManager2 {

        public static final int DEFAULT_CELL_SIZE = 64;

        private Map<Component, Integer> cellConstraints;

        public MonopolyBoardLayout() {
            cellConstraints = new HashMap<>(5);
        }

        public Integer getPosition(Component comp) {
            return cellConstraints.get(comp);
        }

        public void setPosition(Component comp, int position) {
            cellConstraints.put(comp, position);
        }

        @Override
        public void addLayoutComponent(Component comp, Object constraints) {
            if (constraints instanceof Integer) {
                int cell = (int) constraints;
                if (cell >= 0 && cell <= 35) {
                    cellConstraints.put(comp, cell);
                } else {
                    throw new IllegalArgumentException(constraints + " is not within the bounds of a valid cell reference (0-35)");
                }
            } else {
                throw new IllegalArgumentException(constraints + " is not a valid cell reference (integer within 0-35)");
            }
        }

        @Override
        public Dimension maximumLayoutSize(Container target) {
            return new Dimension(DEFAULT_CELL_SIZE * 10, DEFAULT_CELL_SIZE * 10);
        }

        @Override
        public float getLayoutAlignmentX(Container target) {
            return 0.5f;
        }

        @Override
        public float getLayoutAlignmentY(Container target) {
            return 0.5f;
        }

        @Override
        public void invalidateLayout(Container target) {
        }

        @Override
        public void addLayoutComponent(String name, Component comp) {
        }

        @Override
        public void removeLayoutComponent(Component comp) {
            cellConstraints.remove(comp);
        }

        @Override
        public Dimension preferredLayoutSize(Container parent) {
            return new Dimension(DEFAULT_CELL_SIZE * 10, DEFAULT_CELL_SIZE * 10);
        }

        @Override
        public Dimension minimumLayoutSize(Container parent) {
            return new Dimension(DEFAULT_CELL_SIZE * 10, DEFAULT_CELL_SIZE * 10);
        }

        @Override
        public void layoutContainer(Container parent) {
            int width = parent.getWidth();
            int height = parent.getHeight();

            Map<Integer, List<Component>> components = new HashMap<>(25);

            for (Component child : parent.getComponents()) {
                Integer cell = cellConstraints.get(child);
                if (cell != null) {
                    List<Component> children = components.get(cell);
                    if (children == null) {
                        children = new ArrayList<>(4);
                        components.put(cell, children);
                    }
                    children.add(child);
                } else {
                    child.setBounds(0, 0, 0, 0);
                }
            }

            for (Map.Entry<Integer, List<Component>> entry : components.entrySet()) {
                int index = entry.getKey();
                Rectangle bounds = MonopolyBoardLayoutHelper.getCellBounds(index, width, height);
                List<Component> comp = entry.getValue();
                int xDelta = 0;
                int yDelta = 0;
                int availableWidth = bounds.width;
                int availableHeight = bounds.height;
                switch (comp.size()) {
                    case 2:
                        availableWidth /= 2;
                        xDelta = availableWidth;
                        break;
                    case 3:
                    case 4:
                        availableWidth /= 2;
                        xDelta = availableWidth;
                        availableHeight /= 2;
                        yDelta = availableHeight;
                        break;
                }
                int x = bounds.x;
                int y = bounds.y;
                for (int count = 0; count < comp.size() && count < 4; count++) {
                    Component child = comp.get(count);
                    child.setSize(availableWidth, availableHeight);
                    child.setLocation(x, y);

                    x += xDelta;
                    if (x >= bounds.x + bounds.width) {
                        x = bounds.x;
                        y += yDelta;
                    }
                }
            }

        }

    }

}

正如您所看到的，这很快就会变得非常复杂。此示例目前每个单元格仅允许 4 名玩家，因此如果您想要更多玩家，则必须创建自己的算法

关于java - 无法在 JPanel 上移动 JLabel，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/33883330/

文章推荐： c# - 使用 StringWriter 进行 XML 序列化

文章推荐： android - 如何在android中将自定义过滤器应用于相机流？

文章推荐： java - 如何在 TextView 中使用方向箭头

文章推荐： sql - 这个声明是如何运作的？

java - 删除 JPanel 内的 JPanel... 在 JPanel 内
我正在尝试使用 NetBeans 在 Java 中制作类似幻灯片的应用程序。我有一个 JFrame(主窗口)，里面有两个用于导航的按钮(后退和下一步)，还有一个 JPanel(mainPanel)，
java - 在 JPanel 中添加 JPanel - 嵌套的 JPanel 不会显示
新代码 package test; import javax.swing.*; import java.awt.*; public class TestWindow extends JFrame{ /
java - 将 JPanel 内容复制到另一个 JPanel，而不删除原始 JPanel 的内容
我是 Java swing 编码新手。我正在尝试将 JPanel 内容复制到一个新的 JPanel，它使用原始 JPanel 的内容来显示。此外，原始 JPanel 内容随着记录的变化而变化。我尝试了
java - 为什么带有两个 Jpanel 的父 Jpanel 不只显示第一个 Show 本身而不显示其两个子 Jpanels？
我正在尝试创建一个带有另外两个 JPanel 的 JPanel，但是，当时，当我要显示主要内容时JPanel，它只显示主Jpanel上的第一个Jpanel。通过以下示例，您将更好地理解这个问题: 我
java - 尝试将 Jpanel 添加到 JFrame，但在调整 JPanel 窗口大小后将显示 Jpanel 的内容
我正在尝试学习如何使用编码风格在 Java 中完成 GUI 的工作这就是我写的: import java.awt.Container; import java.awt.Panel; import ja
jpanel - 如何使关闭 JPanel 触发一个方法
我从 Oracle 教程中得到了一个 JPanel 的例子我看到它使用默认方法关闭窗口 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 我想
java - JPanel 中的 JPanel
我在使用 Java JPanel 时遇到问题。我想将 2 个具有不同布局的 JPanel 放入一个也有布局的 JPanel 中。有可能让它发挥作用吗？ BibP() setLayout(new
java - JPanel JPanel 内部
我试图让一个 JPanel 出现在另一个 JPanel 中。目前，JPanel 位于外部 JFrame 中，并与我的其他 JFrame 一起加载。我希望 JPanel 位于另一个 JPanel 内部，
java - JPanel 内的 JPanel
是否可以在 Java 的一个方法中在一个面板中包含一个面板？就像，如果我在名为 CreatePanel 的方法中创建了一个 JPanel，我可以在其下面添加另一个吗？我正在尝试在一种方法中添加两个或
java - JPanel 调整大小显示另一个 JPanel
我对嵌套的 BoxLayouts 有疑问。我想构建一个由 2 个子面板组成的 DropDownPanel:顶部的标题和底部的主体。 body 最初是隐藏的。通过单击标题，您可以切换正文的可见性并显示
java - JPanel/JPanel 上的随机矩形
我需要创建一个在 JFrame 或 JPanel 上显示多个矩形的程序。这是我到目前为止提出的代码: import javax.swing.*; import java.util.Random; im
java - 创建一个可选择的包含图像的 jpanels jpanel
将站点中的一些图像保存到 ArrayList 后，我试图创建一个 jpanel，它将在带有滚动 Pane 的单独 jpanel 中显示所有这些图像，以便我可以向每个图像添加 Action 事件。然
java - JPanel 背景图像不适用于其中的 JPanel
我正在开发一个简单的注册窗口，它会在 Java 应用程序打开时出现。这是一个 JFrame，里面有一个 JPanel，它有文本字段、标签，另一个面板也包含文本字段和标签。我的问题是外部面板有背景图像
jpanel - 将 JScrollPane 添加到 JPanel
我有这个界面要创建。我有 JScrollPane 的问题: 我声明了一个带有 Gridlayout(8,1,0,2) 的 JPanel，我希望在这个面板中出现 8 行。一行是一个JPanel，我设置
jpanel - jPanel 图表面板中的 Jfreechart 不显示
我已经创建了 JFreeChart 并将其放入图表面板(按照建议)。我还将它添加到 jPanel 中。我正在使用 jFrame。但是运行程序后我的图表不可见。有谁能帮帮我吗？ final JFreeC
java - 将 JPanel 添加到 JPanel
我在下面附上了我的代码，我的程序的屏幕截图，以及我希望标签看起来像的图形。我需要我的 JPanel textPanel 出现在 LLP 选项卡上的 JButton 下方。我试图将 textPanel
java - 如何删除旧的 JPanel 并添加新的 JPanel？
我想从窗口 (JFrame) 中删除旧的 JPanel 并添加一个新的。我该怎么做呢？我尝试了以下方法: public static void showGUI() { JFrame fram
java - 使用另一个 jPanel 上的按钮修改 jPanel
我刚刚接触 Java，正在为我的大学类(class)开发一个项目。我正在开发一款《百万富翁》游戏，但我陷入困境。我有一个 JFrame 类，其中有 2 个面板。第一个是由按钮组成的，第二个是我想通过
java - 从另一个 JPanel 中重新绘制一个 JPanel
所以，我正在制作一个绘画程序，我有一个主要的Paint类，它检测鼠标输入和绘画，还有一个Tools类，它是左侧的工具栏，拥有许多工具，例如画笔大小更改和形状更改。因此，我想向 Tools 类添加一个清
java - JPanel 已添加到切换按钮单击上的其他 Jpanel 上
我正在尝试制作一个在 JToggleButton 的帮助下激活的弹出面板。我希望在选择 ToggleButton 时将 JPanel 添加到另一个 Jpanel 上，并在取消选择 ToggleButt

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

java - 无法在 JPanel 上移动 JLabel