Java数组循环图形页不起作用

编辑2：我决定，如果我只是把整个代码放在上面，那么你就可以测试它了

编辑：我意识到我说的不清楚，所以我会尽可能地解释。基本上，我使用fillRect方法在图形页面上绘制矩形。问题是，当我更改一个的大小时，它们都会更改，因为每次绘制一个新的时，它们都会被重新绘制。为了纠正这个问题，我在问题的另一部分添加了一个数组来存储通过滚轮输入的所有大小。无论如何，我知道这个问题是孤立于循环的，循环应该把它们都画成一定的大小，所以我添加了一个循环，理论上每次都应该给我一个临时变量，每次运行主循环时都会从0开始重绘矩形的所有大小。问题是，这实际上并没有将矩形重新绘制为各自的大小，而是将它们绘制为当前大小。我也更新了代码部分

我在Java中的一个项目中遇到了问题。它应该做的是更改每个矩形对象的大小，方法是将其存储在数组中，然后根据数组的长度重新创建矩形。我（至少我认为）通过创建一个变量来实现这一点，该变量应该等于程序另一部分中更改的大小，然后将该变量设置为数组中I处的特定元素。无论如何，当我这样做的时候，当我画一个矩形时，我把所有的长度都改成当前的长度。我知道问题在于我在尺寸部分使用I，但我会使用什么？提前感谢您的帮助

代码如下：

public class Dots
{

public static void main(String[] args)
{
  JFrame frame = new JFrame("Array Rectangles");
  frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

  DotsPanel dotsPanel = new DotsPanel();
  frame.getContentPane().add(dotsPanel);

  //buttons
  JButton btnNewButton = new JButton("RED");
  btnNewButton.setHorizontalAlignment(SwingConstants.LEFT);
  btnNewButton.setVerticalAlignment(SwingConstants.BOTTOM);
  btnNewButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent arg0) {
    }
  });
  btnNewButton.setForeground(Color.RED);
  dotsPanel.add(btnNewButton);

  JButton btnNewButton_1 = new JButton("GREEN");
  btnNewButton_1.setForeground(Color.GREEN);
  btnNewButton_1.setVerticalAlignment(SwingConstants.BOTTOM);
  dotsPanel.add(btnNewButton_1);

  JButton btnNewButton_2 = new JButton("BLUE");
  btnNewButton_2.setForeground(Color.BLUE);
  dotsPanel.add(btnNewButton_2);

  JButton btnNewButton_3 = new JButton("BLACK");
  btnNewButton_3.setForeground(new Color(0, 0, 0));
  dotsPanel.add(btnNewButton_3);


  frame.pack();
  frame.setVisible(true);
  }
  }



import java.util.ArrayList;
import java.util.Random;

import javax.swing.JPanel;

import java.awt.*;
import java.awt.event.*;

public class DotsPanel extends JPanel
{
// radius of each dot
private int SIZE = 25;  
private int SIZEAccess;

private static final Random generator = new Random();

//used to count amount of dots
private ArrayList<Point> pointList;

int[] sizes = new int [10000];


//Sets up this std. sized panel to listen for mouse events.
public DotsPanel()
{
    pointList = new ArrayList<Point>();

    addMouseListener (new DotsListener());
    addMouseMotionListener(new DotsListener());
    addMouseWheelListener(new DotsListener());

    setBackground(Color.white);
    setPreferredSize(new Dimension(1024, 768));
}


//used to generate a random color
public static Color randomColor() {
    return new Color(generator.nextInt(256), generator.nextInt(256), generator.nextInt(256));
}

//  Draws all of the dots stored in the list.
public void paintComponent(Graphics page)
{
    super.paintComponent(page);

    //draws a centered dot of random color
    int i = 0;
    for (Point spot : pointList)
    {
        sizes[i] = SIZE;
        //SIZEAccess = SIZE;
        //sizes[i] = SIZEAccess;
        //page.fillRect(spot.x-SIZE, spot.y-SIZE, SIZE*2, SIZE*2);
        for (int temp = 0; temp <= i; temp++)
            page.fillRect(spot.x-sizes[temp], spot.y-sizes[temp], sizes[temp]*2, sizes[temp]*2);
        //page.fillRect(spot.x-SIZE, spot.y-SIZE, SIZE*2, SIZE*2);
        //page.setColor(randomColor());

        //page.setColor(c)
        i++;

    }

    //displays the amount of rectangles drawn at the top left of screen
    page.drawString("Count: " + pointList.size(), 5, 15);

    page.drawString("To change the size of the squares, use mouse scroll wheel.", 350, 15);

    page.drawString("Size: " + SIZE, 950, 15);

}

//  Represents the listener for mouse events.
private class DotsListener implements MouseListener, MouseMotionListener, MouseWheelListener
{

    //  Adds the current point to the list of points and redraws
    //  the panel whenever the mouse button is pressed.

    public void mousePressed(MouseEvent event)
    {
        pointList.add(event.getPoint());
        repaint();
    }


    //  Provide empty definitions for unused event methods.

    public void mouseClicked(MouseEvent event) {

    }
    public void mouseReleased(MouseEvent event) {

    }
    public void mouseEntered(MouseEvent event) {

    }
    public void mouseExited(MouseEvent event) {}


    //  Adds the current point to the list of points and redraws
    //  the panel whenever the mouse button is dragged.
    public void mouseDragged(MouseEvent event) {
        pointList.add(event.getPoint());
        repaint();

    }

    public void mouseMoved(MouseEvent event) {

    }


    public void mouseWheelMoved(MouseWheelEvent event)
    { 
        int notches = 0;
        notches = event.getWheelRotation();
        //int 

        if (notches > 0)
        {
            SIZE = SIZE + notches;
            notches = 0;
        }
        else if (notches < 0)
        {
            int tempSIZE = SIZE;
            tempSIZE = tempSIZE + notches;
            //prevents the program from having dots that increase due to multiplying negatives by negatives 
            //by making anything less than 1 equal 1
            if(tempSIZE < 1)
                tempSIZE = 1;
            SIZE = tempSIZE;
            notches = 0;

        }
    }
}




//SIZE = SIZE + notches;

}

公共类点
{
公共静态void main（字符串[]args）
{
JFrame=新的JFrame（“数组矩形”）；
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
DotsPanel DotsPanel=新的DotsPanel（）；
frame.getContentPane（）.add（dotsPanel）；
//钮扣
JButton btnNewButton=新JButton（“红色”）；
btnNewButton.setHorizontalAlignment（SwingConstants.LEFT）；
btnNewButton.设置垂直对齐（SwingConstants.底部）；
addActionListener（新ActionListener（）{
已执行的公共无效操作（操作事件arg0）{
}
});
设置前景（颜色为红色）；
dotsPanel.add（btnewbutton）；
JButton btnNewButton_1=新JButton（“绿色”）；
btnNewButton_1.设置前景（颜色为绿色）；
BtnewButton_1.设置垂直对齐（SwingConstants.底部）；
dotsPanel.add（btnewbutton_1）；
JButton btnNewButton_2=新JButton（“蓝色”）；
btnNewButton_2.设置前景（颜色：蓝色）；
dotsPanel.add（btnewbutton_2）；
JButton btnNewButton_3=新JButton（“黑色”）；
btnewbutton_3.设置前景（新颜色（0,0,0））；
dotsPanel.add（btnewbutton_3）；
frame.pack（）；
frame.setVisible（true）；
}
}
导入java.util.ArrayList；
导入java.util.Random；
导入javax.swing.JPanel；
导入java.awt.*；
导入java.awt.event.*；
公共类DotsPanel扩展了JPanel
{
//每个点的半径
私有整数大小=25；
私有int SIZEAccess；
专用静态最终随机生成器=新随机（）；
//用于计算点的数量
私有ArrayList点列表；
int[]大小=新int[10000]；
//设置此标准大小的面板以侦听鼠标事件。
公共DotsPanel（）
{
pointList=新的ArrayList（）；
addMouseListener（新的DotsListener（））；
addMouseMotionListener（新的DotsListener（））；
addMouseWheelListener（新的DotsListener（））；
挫折地面（颜色：白色）；
setPreferredSize（新维度（1024768））；
}
//用于生成随机颜色
公共静态颜色randomColor（）{
返回新颜色（generator.nextInt（256）、generator.nextInt（256）、generator.nextInt（256））；
}
//绘制列表中存储的所有点。
公共组件（图形页）
{
super.paintComponent（第页）；
//绘制随机颜色的中心点
int i=0；
对于（点：点列表）
{
尺寸[i]=尺寸；
//SIZEAccess=大小；
//尺寸[i]=尺寸过程；
//page.fillRect（spot.x-SIZE、spot.y-SIZE、SIZE*2、SIZE*2）；
对于（内部温度=0；温度0）
{
尺寸=尺寸+槽口；
缺口=0；
}
否则如果（槽口<0）
{
int tempSIZE=大小；
tempSIZE=tempSIZE+槽口；
//防止程序中出现因负片与负片相乘而增加的点
//通过使小于1的值等于1
如果（tempSIZE<1）
tempSIZE=1；
大小=大小；
缺口=0；
}
}
}
//尺寸=尺寸+槽口；
}

您似乎将ArrayList与数组的交互混为一谈，这让我们很难理解您的逻辑。这表明您的逻辑可能过于复杂，不利于您自己，您的代码可能会从简化中受益。为什么不创建一个

列表

，例如

数组列表

，然后在paintComponent方法中循环遍历该列表，并使用Graphics2D对象的

绘制（…）

或

填充（…）

方法绘制每个矩形：

private List<Rectangle> rectangleList = new ArrayList<>();

@Override
protected void paintComponent(Graphics g) {
   super.paintComponent(g);
   Graphics2D g2 = (Graphics2D) g;
   for (Rectangle rectangle : rectangleList) {
      g2.fill(rectangle);
   }
}

private List rectangleList=new ArrayList（）；
@凌驾
受保护组件（图形g）{
超级组件（g）；
图形2d g2=（图形2d）g；
用于（矩形：矩形列表）{
g2.填充（矩形）；
}
}

例如：

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Stroke;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.List;

import javax.swing.*;

@SuppressWarnings("serial")
public class Foo extends JPanel {
   private static final int PREF_W = 600;
   private static final int PREF_H = PREF_W;
   private static final Color BACKGROUND = Color.black;
   private static final Color FILL_COLOR = Color.pink;
   private static final Color DRAW_COLOR = Color.red;
   private static final Stroke STROKE = new BasicStroke(3);
   private List<Rectangle> rectangleList = new ArrayList<>();
   private Point pressPoint = null;
   private Point dragPoint = null;

   public Foo() {
      setBackground(BACKGROUND);
      MyMouseAdapter myMouseAdapter = new MyMouseAdapter();
      addMouseListener(myMouseAdapter);
      addMouseMotionListener(myMouseAdapter);
   }

   @Override
   public Dimension getPreferredSize() {
      if (isPreferredSizeSet()) {
         return super.getPreferredSize();
      }
      return new Dimension(PREF_W, PREF_H);
   }

   @Override
   protected void paintComponent(Graphics g) {
      super.paintComponent(g);
      Graphics2D g2 = (Graphics2D) g;
      Stroke oldStroke = g2.getStroke();
      g2.setStroke(STROKE);
      for (Rectangle rectangle : rectangleList) {
         g2.setColor(FILL_COLOR);
         g2.fill(rectangle);
         g2.setColor(DRAW_COLOR);
         g2.draw(rectangle);
      }
      g2.setStroke(oldStroke);
      if (pressPoint != null && dragPoint != null) {
         g2.setColor(FILL_COLOR.darker());
         int x = Math.min(pressPoint.x, dragPoint.x);
         int y = Math.min(pressPoint.y, dragPoint.y);
         int width = Math.abs(pressPoint.x - dragPoint.x);
         int height = Math.abs(pressPoint.y - dragPoint.y);
         g2.drawRect(x, y, width, height);
      }
   }

   private class MyMouseAdapter extends MouseAdapter {
      @Override
      public void mousePressed(MouseEvent e) {
         pressPoint = e.getPoint();
         repaint();
      }

      @Override
      public void mouseDragged(MouseEvent e) {
         dragPoint = e.getPoint();
         repaint();
      }

      @Override
      public void mouseReleased(MouseEvent e) {
         dragPoint = e.getPoint();
         int x = Math.min(pressPoint.x, dragPoint.x);
         int y = Math.min(pressPoint.y, dragPoint.y);
         int width = Math.abs(pressPoint.x - dragPoint.x);
         int height = Math.abs(pressPoint.y - dragPoint.y);
         Rectangle rect = new Rectangle(x, y, width, height);
         rectangleList.add(rect);

         pressPoint = null;
         dragPoint = null;
         repaint();
      }
   }

   private static void createAndShowGui() {
      JFrame frame = new JFrame("Foo");
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.getContentPane().add(new Foo());
      frame.pack();
      frame.setLocationRelativeTo(null);
      frame.setVisible(true);
   }

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

import java.awt.BasicStroke；
导入java.awt.Color；
导入java.awt.Dimension；
导入java.awt.Graphics；
导入java.awt.Graphics2D；
导入java.awt.Point；
导入java.awt.Rectangle；
导入java.awt.Stroke；
导入java.awt.event.MouseAdapter；
导入java.awt.event.MouseEvent；
导入java.util.ArrayList；
导入java.util.List；
导入javax.swing.*；
@抑制警告（“串行”）
公共类Foo扩展了JPanel{
专用静态最终整型预调W=600；
私有静态final int PREF_H=PREF_W；
私有静态最终颜色背景