Java 到达某一点时滚动对象

我希望在对象到达y位置=170时向上滚动。然后，当它达到51时，它将再次向下滚动。这是我的密码

import java.awt.*;
import java.applet.*;

public class ani1 extends Applet implements Runnable{

    Thread run01;
    int spacex = 51,spacey = 91;
    int score = 0;

    public void start() {
        if (run01 == null){
            run01 = new Thread(this);
            run01.start();
        }
    }
    public void stop() {
        if(run01 != null){
            run01 = null;
        }
    }
    public void run() {
        while(true){
            repaint();
            try {
                Thread.sleep(30);
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
        } 
    }
    public void paint(Graphics g){
        g.setColor(Color.gray);
        g.fillRoundRect(35, 70, 250, 300, 10, 250);
        g.fillRect(230,20,50,50);
        g.setColor(Color.white);
        g.fillRoundRect(45,85,230,100,10,250);
        g.setColor(Color.black);
        g.drawRect(50, 90, 150, 90);
        g.drawString("SPACE-X",215,100);
        g.drawString("Level: 1",210,120);
        g.drawString("Score : "+ score, 210,135);
        g.drawString("Life : - - -",210,150);
        g.fillRect(spacex, spacey, 10, 10);
        spacey++;
        if(spacey >170){
            spacey--;
        }

    }

}

---

基本上，您应该尝试对您试图移动的对象建模，即使这只是对一个

点

建模，然后您可以使用该点渲染一些任意形状

这意味着您不会在绘制过程中做出逻辑决策。绘制过程应仅侧重于绘制模型

例如

import java.awt.BorderLayout;
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.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;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class Spacy {

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

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

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

    public class TestPane extends JPanel {

        private List<Movable> movables;

        public TestPane() {
            movables = new ArrayList<>(25);
            movables.add(new SpaceObject());

            Timer timer;
            timer = new Timer(40, new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    for (Movable m : movables) {
                        m.move(getSize());
                    }
                    repaint();
                }
            });
            timer.start();

        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(200, 200);
        }

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();
            for (Paintable p : movables) {
                p.paint(g);
            }
            g2d.dispose();
        }
    }

    public interface Paintable {

        public void paint(Graphics g);

    }

    public interface Movable extends Paintable {

        public void setLocation(Point p);
        public Point getLocation();
        public void move(Dimension size);

    }

    public class SpaceObject implements Movable {

        private Point p;

        public SpaceObject() {
            setLocation(new Point(150, 50));
        }

        @Override
        public void setLocation(Point p) {
            this.p = p;
        }

        @Override
        public Point getLocation() {
            return p;
        }

        @Override
        public void paint(Graphics g) {

            g.setColor(Color.RED);
            Point p = getLocation();
            int radius = 10;
            g.fillOval(p.x - (radius / 2), p.y - (radius / 2), radius, radius);

        }

        @Override
        public void move(Dimension size) {
            Point p = getLocation();
            int delatX = 0;
            int delatY = 0;
            int gap = size.height / 4;
            if (p.y == gap) {
                delatX = 2;
            } else if (p.y == size.height - gap) {
                delatX = -2;
            }
            gap = size.width / 4;
            if (p.x == gap) {
                delatY = -2;
            } else if (p.x == size.width - gap) {
                delatY = 2;
            }
            p.x += delatX;
            p.y += delatY;

            if (p.x < (size.width / 4)) {
                p.x = size.width / 4;
            } else if (p.x > (size.width - (size.width / 4))) {
                p.x = size.width - (size.width / 4);
            }
            if (p.y < (size.height / 4)) {
                p.y = size.height / 4;
            } else if (p.y > (size.height - (size.height / 4))) {
                p.y = size.height - (size.height / 4);
            }

            setLocation(p);
        }            
    }        
}

导入java.awt.BorderLayout；
导入java.awt.Color；
导入java.awt.Dimension；
导入java.awt.EventQueue；
导入java.awt.Graphics；
导入java.awt.Graphics2D；
导入java.awt.Point；
导入java.awt.event.ActionEvent；
导入java.awt.event.ActionListener；
导入java.util.ArrayList；
导入java.util.List；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
导入javax.swing.Timer；
导入javax.swing.UIManager；
导入javax.swing.UnsupportedLookAndFeelException；
公共类空间{
公共静态void main（字符串[]args）{
新空间（）；
}
公共空间（）{
invokeLater（新的Runnable（）{
@凌驾
公开募捐{
试一试{
UIManager.setLookAndFeel（UIManager.getSystemLookAndFeelClassName（））；
}catch（ClassNotFoundException |实例化Exception | IllegalacessException |不支持ookandfeelException ex）{
}
JFrame=新JFrame（“测试”）；
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
frame.setLayout（新的BorderLayout（））；
frame.add（newtestpane（））；
frame.pack（）；
frame.setLocationRelativeTo（空）；
frame.setVisible（true）；
}
});
}
公共类TestPane扩展了JPanel{
私有动产清单；
公共测试窗格（）{
动产=新阵列列表（25）；
添加（新的SpaceObject（））；
定时器；
计时器=新计时器（40，新ActionListener（）{
@凌驾
已执行的公共无效操作（操作事件e）{
用于（动产m：动产）{
m、 move（getSize（））；
}
重新油漆（）；
}
});
timer.start（）；
}
@凌驾
公共维度getPreferredSize（）{
返回新维度（200200）；
}
@凌驾
受保护组件（图形g）{
超级组件（g）；
Graphics2D g2d=（Graphics2D）g.create（）；
用于（可涂漆p：动产）{
p、 油漆（g）；
}
g2d.dispose（）；
}
}
公共界面可绘制{
公共空间涂料（图g）；
}
公共接口可移动扩展可绘制{
公共无效设置位置（p点）；
公共点getLocation（）；
公共空间移动（维度大小）；
}
公共类SpaceObject实现可移动{
私人点p；
公共空间对象（）{
设定位置（新点（150,50））；
}
@凌驾
公共无效设置位置（点p）{
这个，p=p；
}
@凌驾
公共点getLocation（）{
返回p；
}
@凌驾
公共空间涂料（图g）{
g、 setColor（Color.RED）；
点p=getLocation（）；
int半径=10；
g、 圆角（p.x-（半径/2），p.y-（半径/2），半径，半径）；
}
@凌驾
公共空心移动（尺寸标注大小）{
点p=getLocation（）；
int delatX=0；
int delatY=0；
内部间隙=尺寸。高度/4；
如果（p.y==差距）{
delatX=2；
}否则如果（p.y==尺寸高度-间隙）{
delatX=-2；
}
间隙=尺寸。宽度/4；
如果（p.x==间隙）{
delatY=-2；
}否则如果（p.x==size.width-间隙）{
delatY=2；
}
p、 x+=delatX；
p、 y+=delatY；
如果（p.x<（尺寸宽度/4））{
p、 x=尺寸。宽度/4；
}否则如果（p.x>（size.width-（size.width/4）））{
p、 x=尺寸.宽度-（尺寸.宽度/4）；
}
如果（p.y<（尺寸高度/4））{
p、 y=尺寸。高度/4；
}否则（p.y>（size.height-（size.height/4）））{
p、 y=尺寸高度-（尺寸高度/4）；
}
设置位置（p）；
}            
}        
}

您的代码有两个基本问题

您正试图决定如何在paint方法中绘制输出。一般来说，这是不可取的。当你养成其他坏习惯时

在绘制之前，您不会更新

图形

上下文。基本上是这样的，你得到的是上一个绘制周期中使用的相同的

图形
上下文，这意味着当你到达最后并想要开始向后滚动时，你之前绘制的仍然存在

我建议：

您避免使用

Applet

并使用

JApplet

，事实上，我会完全避免使用Applet，只需使用

JFrame

作为基本容器，它们的问题就更少了

基于类似

JPanel

的内容创建自定义组件，并覆盖它的

paintComponent

方法，然后在那里执行自定义绘制

确保首先调用

super.paintComponent

，因为这将为您准备

图形

上下文

就个人而言，我会避免使用

线程

对于这种情况，它会带来额外的复杂性，相反，我会