将 JLabel 添加到 JPanel 是否会“隐藏”JPanel？

如果我在 GridLayout 中有几个 JPanel，每个 JPanel 都有一个 MouseAdapter，然后创建 JLabels（带有文本）并添加到每个 JPanel 中。请注意，JLabels 没有侦听器。 如果我渲染它并尝试单击 JPanel，或者最终尝试单击 JLabel，MouseAdapter 会将其注册为事件吗？

基本上，我希望 JPanel 注册事件，并且 JPanel 仅在 JPanel 顶部显示文本。此外，面板还有背景颜色。

如果 JLabel 确实“隐藏”了事件注册，我该如何解决这个问题？

顶部组件将获得鼠标点击。 JLabel 将覆盖的范围取决于其大小和 JPanel 的布局管理器。一种方法是将侦听器提供给 JLabel（如上所述），但另一种方法是如我下面所述，虽然可能不是最好的方法，但它对我来说效果很好：

1) JLayeredPane 包含所有内容并具有作为 MouseListener 和 MouseMotionListener 添加的 MouseAdapter。

2) 一个名为“board”的 JPanel，它使用 GridLayout(8, 8)，其大小与添加到分层窗格底层的 JLayeredPane 的大小完全相同，或者更准确地说，是 JLayeredPane.DEFAULT_LAYER。

3）这个JPanel在GridLayout中保存了64个其他小JPanel方块（实际上这些方块是从JPanel扩展而来的），并且每个都使用GridBagLayout。

4) 棋子是JLabels，由JPanel 方块保存。

5) 在 MouseAdapter mousePressed 方法中，我通过 e.getPoint 获取鼠标所在的 Point, p（如果 e 是传递给该方法的 MouseEvent 对象）。然后，我通过调用 JPanel 板上的 findComponentAt(p) 来找出哪个方块包含该点。然后我检查这个方块是否能容纳一块。如果是这样，则将该块从正方形中移除并直接添加到 JLayeredPane 的 JLayeredPane.DRAG_LAYER 中。

6) 如果棋子被放置在 JLayeredPane 的 JLayeredPane.DRAG_LAYER 中，MouseAdapter 的 mouseDragged 方法将控制棋子的位置。

7) 在 mouseRelease 上，我再次使用与上面相同的技术，使用 findComponentAt(p) 找出哪个方块保存了鼠标的位置或点，如果它是有效的方块，我从 JLayeredPane 的 JLayeredPane.DRAG_LAYER 中删除棋子并放置它在广场上。如果棋子不在棋盘上或者不是有效的方格，我会将棋子放回原来的位置。

请注意，如果板 JPanel 没有完全填充 JLayeredPane，则在调用 findComponentAt(p) 之前必须使用其在 JLayeredPane 内的偏移量来更正位置 Point, p，因为 MouseAdapter 将返回相对于 JLayeredPane 而不是板 JPanel 的 Points 。

例如：

import java.awt.*;
import java.awt.event.*;
import java.awt.image.BufferedImage;
import javax.swing.*;

public class Chess2 {
    private static void createAndShowUI() {
        JFrame frame = new JFrame("Chess 2");
        frame.getContentPane().add(new Chess2Gui().getMainComponent());
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                createAndShowUI();
            }
        });
    }
}

class Chess2Gui {
    private static final int RANKS = 8;
    private static final int FILES = 8;
    private static final Color DARK_COLOR = new Color(0, 100, 0);
    private static final Color LIGHT_COLOR = new Color(200, 200, 200);
    private static final Color DARK_PIECE_COLOR = Color.black;
    private static final int SQR_WIDTH = 80;
    private static final int PIECE_WIDTH = 60;
    private static final Dimension SQR_SIZE = new Dimension(SQR_WIDTH, SQR_WIDTH);

    private JLayeredPane mainLayeredPane = new JLayeredPane();
    private JPanel board = new JPanel(new GridLayout(RANKS, FILES));
    private JPanelSquare[][] jPanelSquareGrid = new JPanelSquare[RANKS][FILES];

    public Chess2Gui() {
        for (int rank = 0; rank < RANKS; rank++) {
            for (int file = 0; file < FILES; file++) {
                Color bkgd = DARK_COLOR;
                if (rank % 2 == file % 2) {
                    bkgd = LIGHT_COLOR;
                } 
                jPanelSquareGrid[rank][file] = new JPanelSquare(rank, file, bkgd);
                jPanelSquareGrid[rank][file].setPreferredSize(SQR_SIZE);
                board.add(jPanelSquareGrid[rank][file]);
            }
        }
        board.setSize(board.getPreferredSize());
        board.setLocation(0, 0);
        mainLayeredPane.add(board, JLayeredPane.DEFAULT_LAYER);
        mainLayeredPane.setPreferredSize(board.getPreferredSize());

        ImageIcon icon = new ImageIcon(ImageUtils2.createImage(PIECE_WIDTH, DARK_PIECE_COLOR));
        JLabel chessPiece = new JLabel(icon, SwingConstants.CENTER);

        jPanelSquareGrid[1][3].add(chessPiece);

        MyMouseAdapter mouseAdapter = new MyMouseAdapter();
        mainLayeredPane.addMouseListener(mouseAdapter);
        mainLayeredPane.addMouseMotionListener(mouseAdapter);

    }

    public JComponent getMainComponent() {
        return mainLayeredPane;
    }

    private class MyMouseAdapter extends MouseAdapter {
        private JLabel piece = null;
        private Point delta = null;
        private int oldRank = -1;
        private int oldFile = -1;

        @Override
        public void mousePressed(MouseEvent e) {
            Point p = e.getPoint();
            Component c = board.getComponentAt(p);
            for (int rank = 0; rank < jPanelSquareGrid.length; rank++) {
                for (int file = 0; file < jPanelSquareGrid[rank].length; file++) {
                    if (jPanelSquareGrid[rank][file] == c) {
                        if (jPanelSquareGrid[rank][file].getChessPiece() != null) {

                            // the jPanelSquares are derived from JPanel but have a 
                            // few of their own methods
                            piece = jPanelSquareGrid[rank][file].getChessPiece();
                            jPanelSquareGrid[rank][file].remove(piece);
                            oldRank = rank;
                            oldFile = file;
                            mainLayeredPane.add(piece, JLayeredPane.DRAG_LAYER);
                            int x = p.x - PIECE_WIDTH/2;
                            int y = p.y - PIECE_WIDTH/2;
                            piece.setLocation(x, y);

                            delta = new Point(p.x - x, p.y - y);
                            board.revalidate();
                            mainLayeredPane.repaint();
                            return;
                        }
                    }
                }
            }

            oldFile = -1;
            oldRank = -1;
        }

        @Override
        public void mouseDragged(MouseEvent e) {
            if (piece != null) {
                Point p = e.getPoint();
                int x = p.x - delta.x;
                int y = p.y - delta.y;
                piece.setLocation(x, y);
                mainLayeredPane.revalidate();
                mainLayeredPane.repaint();
            }
        }

        @Override
        public void mouseReleased(MouseEvent e) {
            if (piece != null) {
                JPanelSquare sqr = (JPanelSquare) board.getComponentAt(e.getPoint());
                mainLayeredPane.remove(piece);
                if (sqr == null || !validMove(sqr)) {
                    jPanelSquareGrid[oldRank][oldFile].add(piece);
                } else {
                    sqr.add(piece);
                }

                piece = null;
                delta = null;

                oldRank = -1;
                oldFile = -1;

                board.revalidate();
                mainLayeredPane.repaint();
            }
        }

        // just a pawn's moves
        private boolean validMove(JPanelSquare sqr) {
            int rank = sqr.getRank();
            int file = sqr.getFile();

            if (file != oldFile) {
                return false;
            }
            if (oldRank == 1 && (rank != 2 && rank != 3)) {
                return false;
            }
            if (oldRank != 1 && rank != oldRank + 1) {
                return false;
            }
            return true;
        }
    }
}

@SuppressWarnings("serial")
class JPanelSquare extends JPanel {
    private int rank;
    private int file;
    private JLabel chessPiece = null;

    public JPanelSquare(int rank, int file, Color bkgrnd) {
        this.rank = rank;
        this.file = file;
        setBackground(bkgrnd);
        setLayout(new GridBagLayout());
    }

    public int getRank() {
        return rank;
    }
    public int getFile() {
        return file;
    }

    @Override
    public Component add(Component c) {
        chessPiece = (JLabel)c;
        return super.add(c);
    }

    @Override
    public void remove(Component comp) {
        chessPiece = null;
        super.remove(comp);
    }

    public JLabel getChessPiece() {
        return chessPiece;
    }
}

class ImageUtils2 {

    public static BufferedImage createImage(int size, Color color) {
        BufferedImage img = new BufferedImage(size, size, BufferedImage.TYPE_INT_ARGB);
        Graphics2D g2 = img.createGraphics();
        g2.setColor(color);
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, 
                    RenderingHints.VALUE_ANTIALIAS_ON);
        g2.fillOval(size/3, 0, size/3, size/3);
        g2.fillOval(size/4, size/4, size/2, 2*size/3);
        g2.fillOval(size/6, 2*size/3, 2*size/3, size/2);
        g2.dispose();
        return img;
    }

}