Java Swing-在不重写的情况下绘制JPanel

我知道绘制

JPanel

的正确方法是创建一个扩展

JPanel

并重写

paintComponent

方法的类。这很好，但在制作

JPanels

之前，我不知道我想画什么

我在

GridLayout

中有一个主

JPanel

。网格中填充了其他

jpanel

。这些

jpanel

也在二维数组中跟踪。基于按钮事件或其他事件，我希望能够简单地在这个数组中循环，获取图形，然后重新绘制。然而，这并不太好。我想做的一个例子是：

for (int row = 0; row < GRID_ROWS; row++) {
    for (int col = 0; col < GRID_COLS; col++) {
        JPanel tmp_panel = new JPanel();
        Graphics g = panelGrid[row][col].getGraphics();
        Graphics2D g2d = (Graphics2D)g;
        //Do some drawing
        panelGrid[row][col] = tmp_panel;
        backingPanel.add(panelGrid[row][col]);
    }
}

for（int row=0；row

在代码的后面，可能还有另一个事件，我希望能够简单地循环并重新绘制面板：

for (int row = 0; row < GRID_ROWS; row++) {
    for (int col = 0; col < GRID_COLS; col++) {
        Graphics g = panelGrid[row][col].getGraphics();
        Graphics2D g2d = (Graphics2D)g;
        //Do some drawing
        panelGrid[row][col].repaint()

    }
}

for（int row=0；row

---

我从来没有写过第二个块，因为第一个块总是抱怨图形没有初始化。

你能做的是有一个原型面板，它使用任何实现接口的类，比如说

Drawable

，它有一个

draw（graphics g）

方法需要重写

public interface Drawable {
    public void draw(Graphics g);
}

您的原型面板调用可以如下所示

public class DrawablePanel extends JPanel {
    private Drawable drawable;


    public DrawablePanel(Drawable drawable) {
        this.drawable = drawable;
    }

    public DrawablePanel() {

    }

    public void setDrawable(Drawable drawable) {
        this.drawable = drawable;
        repaint();
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2 = (Graphics2D)g;
        if (drawable != null) {
            drawable.draw(g2);
        }
    }
}

只有当

Drawable

对象不为空时，它才会绘制任何内容。可以在实例化时将

Drawable

对象传递给它，也可以稍后设置

Drawable

对象

因此，您可以创建

Drawable面板的数组

，并随时设置

Drawable

属性

可绘制的

实现的示例可以是

public class Ball implements Drawable {
    @Override
    public void draw(Graphics g) {
        g.fillOval(0, 0, 50, 50);
    }
}

---

更新

这里有一个你可以玩的例子

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

public class LoopPanelPaint {
    private static final int ROUND_SQR = 0;
    private static final int BALL = 1;

    private List<Color> colorList;

    public LoopPanelPaint() {
        JPanel matrixPanel = new JPanel();
        DrawablePanel[][] drawPanels = createPanelMatrix(matrixPanel);

        colorList = createColorList();

        JButton createImages = createButton(drawPanels);

        JFrame frame = new JFrame();
        frame.add(matrixPanel);
        frame.add(createImages, BorderLayout.SOUTH);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }

    public JButton createButton(final DrawablePanel[][] panels) {
        JButton button = new JButton("Create Images");
        button.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent e) {
                addShapesToPanels(panels);
            }
        });
        return button;
    }

    private DrawablePanel[][] createPanelMatrix(JPanel panel) {
        panel.setLayout(new GridLayout(10, 10));
        DrawablePanel[][] panels = new DrawablePanel[10][10];
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                DrawablePanel drawPanel = new DrawablePanel();
                panels[i][j] = drawPanel;
                panel.add(drawPanel);
            }
        }
        return panels;
    }

    private void addShapesToPanels(DrawablePanel[][] panels) {
        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                int type = random.nextInt(2);
                Drawable drawable = getRandomDrawable(type);
                int colorIndex = random.nextInt(colorList.size());
                Color color = colorList.get(colorIndex);
                panels[i][j].setColor(color);
                panels[i][j].setDrawable(drawable);
            }
        }
    }

    private Drawable getRandomDrawable(int type) {
        switch (type) {
        case ROUND_SQR:
            return new RoundSquare();
        case BALL:
            return new Ball();
        default:
            return null;
        }
    }

    private List<Color> createColorList() {
        List<Color> colors = new ArrayList<>();
        colors.add(Color.blue);
        colors.add(Color.red);
        colors.add(Color.gray);
        colors.add(Color.green);
        colors.add(Color.orange);
        colors.add(Color.magenta);
        colors.add(Color.yellow);
        colors.add(Color.cyan);
        return colors;
    }

    public class DrawablePanel extends JPanel {

        private Drawable drawable;
        private Color color = Color.black;

        public DrawablePanel(Drawable drawable) {
            this.drawable = drawable;
        }

        public DrawablePanel() {

        }

        public void setDrawable(Drawable drawable) {
            this.drawable = drawable;
            repaint();
        }

        public void setColor(Color color) {
            this.color = color;
        }

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2 = (Graphics2D) g;
            g2.setColor(color);
            if (drawable != null) {
                drawable.draw(g2);
            }
        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(Drawable.SIZE, Drawable.SIZE);
        }
    }

    public class Ball implements Drawable {

        @Override
        public void draw(Graphics g) {
            g.fillOval(0, 0, Drawable.SIZE, Drawable.SIZE);
        }
    }

    public class RoundSquare implements Drawable {

        @Override
        public void draw(Graphics g) {
            g.fillRoundRect(0, 0, Drawable.SIZE, Drawable.SIZE, 10, 10);

        }

    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                new LoopPanelPaint();
            }
        });

    }

}

interface Drawable {
    public static final int SIZE = 50;

    public void draw(Graphics g);
}

导入java.awt.BorderLayout；
导入java.awt.Color；
导入java.awt.Dimension；
导入java.awt.Graphics；
导入java.awt.Graphics2D；
导入java.awt.GridLayout；
导入java.awt.event.ActionEvent；
导入java.awt.event.ActionListener；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.Random；
导入javax.swing.JButton；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
导入javax.swing.SwingUtilities；
公营油漆{
私有静态最终整数舍入_SQR=0；
私人静态最终整型球=1；
私人名单；
公共油漆{
JPanel matrixPanel=新的JPanel（）；
DrawablePanel[][]drawPanels=createPanelMatrix（matrixPanel）；
colorList=createColorList（）；
JButton createImages=createButton（绘图面板）；
JFrame=新JFrame（）；
frame.add（matrixPanel）；
frame.add（createImages，BorderLayout.SOUTH）；
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
frame.pack（）；
frame.setLocationRelativeTo（空）；
frame.setVisible（true）；
}
公共JButton createButton（最终可绘制面板[][]面板）{
JButton按钮=新JButton（“创建图像”）；
addActionListener（新建ActionListener（））{
已执行的公共无效操作（操作事件e）{
添加形状面板（面板）；
}
});
返回按钮；
}
专用DrawablePanel[][]createPanelMatrix（JPanel面板）{
panel.setLayout（新网格布局（10,10））；
DrawablePanel[][]面板=新的DrawablePanel[10][10]；
对于（int i=0；i<10；i++）{
对于（int j=0；j<10；j++）{
DrawablePanel drawPanel=新的DrawablePanel（）；
面板[i][j]=图纸面板；
面板。添加（drawPanel）；
}
}
返回面板；
}
专用void addShapeStopPanels（DrawablePanel[][]面板）{
随机=新随机（）；
对于（int i=0；i<10；i++）{
对于（int j=0；j<10；j++）{
int type=random.nextInt（2）；
可绘制可绘制=getRandomDrawable（类型）；
int colorIndex=random.nextInt（colorList.size（））；
Color=colorList.get（colorIndex）；
面板[i][j].setColor（颜色）；
面板[i][j]。可设置可拉伸（可拉伸）；
}
}
}
私有可提取getRandomDrawable（int类型）{
开关（类型）{
案件轮审：
返回新的RoundSquare（）；
案例球：
返回新球（）；
违约：
返回null；
}
}
私有列表createColorList（）{
列表颜色=新的ArrayList（）；
颜色。添加（颜色。蓝色）；
颜色。添加（颜色。红色）；
颜色。添加（颜色。灰色）；
颜色。添加（颜色。绿色）；
颜色。添加（颜色。橙色）；
颜色。添加（颜色。洋红色）；
颜色。添加（颜色。黄色）；
颜色。添加（颜色。青色）；
返回颜色；
}
公共类DrawablePanel扩展了JPanel{
私人提款；
私有颜色=Color.black；
公共可拉伸面板（可拉伸）{
this.drawable=drawable；
}
公共事务委员会（）{
}
公共空间可设置可提取（可提取可提取）{
this.drawable=drawable；
重新油漆（）；
}
公共空间设置颜色（颜色）{
这个颜色=颜色；
}
@凌驾
受保护组件（图形g）{
超级组件（g）；
格拉