如何将视觉添加到 JComponent
Posted
技术标签:
【中文标题】如何将视觉添加到 JComponent【英文标题】：How to add vision to a JComponent 【发布时间】：2021-12-20 21:19:50 【问题描述】：我有一个动态数量的 JComponent 在 JPanel 中移动。我想让它们在另一个 Jcomponent 出现时停止。我试图搜索 2d 光线投射，不幸的是我不知道如何在我的代码中实现它。 Stackoferflow 对此有一些答案，但他们正在构建对撞机，我需要更类似于光线投射的东西。
这是 JPanel 代码Map.java:
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Map extends JPanel implements ActionListener
final int windowWidth = 1300;
final int windowHeight = 750;
Map()
this.setPreferredSize(new Dimension(windowWidth, windowHeight));
Timer timer = new Timer(3000, this);
timer.start();
@Override
public void paint(Graphics g)
super.paint(g);
// painting map
// Update method of the frame
@Override
public void actionPerformed(ActionEvent e)
Car car = new Car();
this.add(car);
// For loop responds for data cleaning
for(int i=0;i<this.getComponents().length;i++)
Car iCar = (Car) this.getComponents()[i];
if(iCar.x >= 1400 || iCar.x <= -300 || iCar.y <= -300 || iCar.y >= 950)
this.remove(i);
System.out.println(this.getComponentCount());
this.updateUI();
Heres JComponent 代码Car.java:
import javax.imageio.ImageIO;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Random;
public class Car extends JComponent implements ActionListener
private BufferedImage car;
private final GeoPoint startPoint = GeoSides.pickGeoPoint();
public int x = 0;
public int y = 0;
private int xVelocity;
private int yVelocity;
private final int imageX = 160;
private final int imageY = 120;
private double turnAngle = 0;
Timer timer;
// Initializing Car() object
Car()
this.setPreferredSize(new Dimension(170, 130));
this.timer = new Timer(1, this); // Setting up the timer for update method
this.timer.start();
try
Random randomize = new Random();
car = ImageIO.read(new File("src/assets/" + (randomize.nextInt(10) + 1) + ".png")); // Getting a random image of car
catch (IOException e)
e.printStackTrace();
// Setting start position
// This method should be called when another car is in the way
public void stopCar()
xVelocity = 0;
yVelocity = 0;
// Method scales the image and rotate it if needed
private void drawCar(Graphics2D render2D, double rotationAngle)
//Image scaling and rotating
// Inherited method from JComponent
@Override
public void paintComponent(Graphics g)
super.paintComponent(g);
this.setLocation(new Point(x, y));
Graphics2D render2D = (Graphics2D) g;
drawCar(render2D, turnAngle);
// Frame update of car's x, y speed and turn angle
@Override
public void actionPerformed(ActionEvent e)
switch (startPoint)
// Setting destination points
x += xVelocity;
y += yVelocity;
this.repaint();
【问题讨论】：
1.不要打电话给updateUI，它没有做你认为它正在做的事情。 2. 我个人不会以这种方式使用组件。 3.您的“主循环”应该确保对“实体”的任何更改都不会导致冲突，如果发生冲突，那么您需要采取适当的措施
4.在paintComponent 中调用this.setLocation(new Point(x, y)); 不会导致任何问题，因为Graphics 上下文实际上是在调用paintComponent 之前翻译的（因此0x0 是组件在其父级中的位置）跨度>
我可以用什么来代替updateUI()。我如何解决setLocation() 的问题，我尝试在类构造函数中设置它但没有工作。你所说的“主循环”是什么意思？
“主循环”是在常规基础上触发的回调方法，即Map 中的actionPerformed 方法。这应该负责更新状态、执行碰撞检测、根据需要执行其他操作并安排重绘。通常，您可能只需要repaint，但如果您使用Components，则可能需要单独重新绘制每个组件。在“主循环”中，您应该设置实体的位置
您使用单个绘图 JPanel 并将汽车绘制为图像精灵而不是组件。这是一个非常轻量级的事情，因此在资源上更容易，最终也更容易编写。您还需要通过创建非 GUI 模型类来控制程序运行时的状态，从而将您的逻辑与 GUI 很好地分开，而 GUI 或“视图”只是显示该状态并从用户那里获取输入。跨度>
【参考方案1】：
-
不要打电话给
updateUI，它不是在做你认为它在做的事情。要安排新的绘制通道，您应该在已更改的组件上调用 repaint。
我个人不会以这种方式使用组件。
您的“主循环”应确保对“实体”的任何更改都不会导致冲突，如果发生冲突，那么您需要采取适当的措施
在paintComponent 中调用this.setLocation(new Point(x, y)); 不会导致任何问题，因为Graphics 上下文实际上是在@987654327 之前翻译的（因此0x0 是组件在其父级中的位置） @被调用
Swing Timer 不能很好地扩展。也就是说，拥有更多Timers 实际上可能会对部门绩效产生影响。最好有一个 Timer 可以附加多个侦听器，或者更好的是，一个Timer 和单个侦听器充当“主循环”
“主循环”是什么意思？
“主循环”是一个常用术语（尤其是在游戏中，但 Swing 将其称为“事件调度线程”或“主事件循环”）。在您的上下文中，这将是您的Map 类中的Timer 的ActionListener。
这应该定期调用，它负责根据实体的需要更新实体、执行碰撞检测、以任何其他有意义的方式更新状态以及安排重绘。
示例
下面的例子简化了这个想法。它使用一个“主循环”，负责更新“实体”位置、执行边界和碰撞检测以及安排重绘。
请注意，这是一个过于简化的示例。我个人会将Entity 设为interface，然后创建一个专用的Car 类来实现，但这只是为了演示核心概念
import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;
public class Main
public static void main(String[] args)
new Main();
public Main()
EventQueue.invokeLater(new Runnable()
@Override
public void run()
JFrame frame = new JFrame();
frame.add(new MainPane());
frame.pack();
frame.setLocationRelativeTo(null);
frame.setVisible(true);
);
public class MainPane extends JPanel
private Timer ticker;
private List<Entity> entities;
public MainPane()
entities = new ArrayList<>(32);
// For demonstration purposes
int y = (200 - 20) / 2;
entities.add(new Entity(0, y, 1, 0, Color.RED));
entities.add(new Entity(400 - 20, y, -1, 0, Color.BLUE));
@Override
public Dimension getPreferredSize()
return new Dimension(400, 200);
@Override
public void addNotify()
super.addNotify();
if (ticker != null)
ticker.stop();
ticker = null;
ticker = new Timer(5, new ActionListener()
@Override
public void actionPerformed(ActionEvent e)
tickDidOccur();
);
ticker.start();
@Override
public void removeNotify()
super.removeNotify();
if (ticker != null)
ticker.stop();
ticker = null;
// It's more efficent then creating a local variable each time
private List<Entity> entitiesToBeRemoved = new ArrayList<>(32);
protected void tickDidOccur()
entitiesToBeRemoved.clear();
// So some choices. You can either update ALL the enties and then
// do the collision detection, or, you can do the collision detection
// after each enity is been updated.
Rectangle viewBounds = getBounds();
for (Entity entity : entities)
Rectangle bounds = entity.peekNextPosition();
if (!viewBounds.intersects(bounds))
entitiesToBeRemoved.add(entity);
else
boolean conflict = false;
for (Entity other : entities)
if (other == entity)
continue;
// Please note, depending on the amount of change
// it's possible that the enities may be positioned
// further apart. You will need to access this based
// on your needs.
// Bascially what this is going to do, is check to see
// if the next update can be perform or not, if there
// is a conflict, the entities are stopped and the
// current entities update is discarded
if (bounds.intersects(other.bounds))
other.stop();
entity.stop();
conflict = true;
if (!conflict)
// Commit the next position
entity.update();
// This is more of a "long winded" bounds check, but as you
// can see, we can simply make use of the functionality
// Rectangle provides to do the same thing
//if (bounds.x + bounds.width < 0 || bounds.y + bounds.height < 0)
// entitiesToBeRemoved.add(entity);
// else if (bounds.x > getWidth() || bounds.y > getHeight())
// entitiesToBeRemoved.add(entity);
//
entities.removeAll(entitiesToBeRemoved);
repaint();
@Override
protected void paintComponent(Graphics g)
super.paintComponent(g);
for (Entity entity : entities)
// Because I trust no one
Graphics2D g2d = (Graphics2D) g.create();
entity.paint(g2d);
g2d.dispose();
public class Entity
private Rectangle bounds;
private Point velocity;
private Color color;
public Entity(int x, int y, int xDelta, int yDelta, Color color)
bounds = new Rectangle(x, y, 20, 20);
velocity = new Point(xDelta, yDelta);
this.color = color;
public Rectangle getBounds()
return bounds;
public Color getColor()
return color;
public void stop()
velocity = new Point(0, 0);
public void start(int xDelta, int yDelta)
velocity = new Point(0, 0);
public Rectangle peekNextPosition()
Rectangle next = new Rectangle(bounds);
int x = next.x + velocity.x;
int y = next.y + velocity.y;
next.setLocation(x, y);
return next;
public Rectangle update()
int x = bounds.x + velocity.x;
int y = bounds.y + velocity.y;
bounds.setLocation(x, y);
return bounds;
public void paint(Graphics2D g)
Graphics2D g2d = (Graphics2D) g.create();
// Now what ever we do wont' have a cascading effect on what
// ever comes next. This is really helpful for when you need
// to apply AffineTransformation
g2d.setColor(getColor());
g2d.fill(bounds);
g2d.dispose();
为什么不使用基于“组件”的实体？
主要原因是，它们“重”。它们具有许多核心功能，旨在完成其他工作，但它们的设计并不适合此类工作。
组件已经有很多与之关联的位置/大小操作，这些操作通常由布局管理 API 管理，因此您可能（很容易）最终与之抗争。
组件通常不太适合这种工作。
【讨论】：
以上是关于如何将视觉添加到 JComponent的主要内容，如果未能解决你的问题，请参考以下文章