java - 使两个物体同时旋转

Question

所以我有一个任务，我必须让两个对象同时移动。我知道我应该使用线程类，但我不知道该怎么做。我的项目有两个文件。第一个有 main 方法并实现了 fan 对象。如下:

import javax.swing.JFrame;
import javax.swing.JPanel;
import java.awt.Graphics;


    public class DrawArcs extends JFrame {
    public DrawArcs() {
        setTitle("DrawArcs");
        add(new ArcsPanel());
     }

     /** Main method */
    public static void main(String[] args) {
        DrawArcs frame = new DrawArcs();
        frame.setLocationRelativeTo(null); // Center the frame
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(300, 300);
        frame.setVisible(true);
        frame.add(new StillClock());


     }
    }

    class ArcsPanel extends JPanel {
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);

        int xCenter = getWidth() / 2;
        int yCenter = getHeight() / 2;
        int radius = (int)(Math.min(getWidth(), getHeight()) * 0.4);

        int x = xCenter - radius;
        int y = yCenter - radius;

        g.fillArc(x, y, 2 * radius, 2 * radius, 0, 30);
        g.fillArc(x, y, 2 * radius, 2 * radius, 90, 30);
        g.fillArc(x, y, 2 * radius, 2 * radius, 180, 30);
        g.fillArc(x, y, 2 * radius, 2 * radius, 270, 30);
    }
 }

我的第二个文件包含时钟类的实现。

public class StillClock  extends JPanel {
    private int hour;
    private int minute;
    private int second;


    public StillClock() {
        setCurrentTime();
    }


    public StillClock(int hour, int minute, int second) {
        this.hour = hour;
        this.minute = minute;
        this.second = second;
    }
////there are setters and getters here
 .
 .
 . 
////

    @Override /** Draw the clock */
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);

        // Initialize clock parameters
        int clockRadius =
                (int)(Math.min(getWidth(), getHeight()) * 0.8 * 0.5);
        int xCenter = getWidth() / 2;
        int yCenter = getHeight() / 2;

        // Draw circle
        g.setColor(Color.black);
        g.drawOval(xCenter - clockRadius, yCenter - clockRadius,
                2 * clockRadius, 2 * clockRadius);
        g.drawString("12", xCenter - 5, yCenter - clockRadius + 12);
        g.drawString("9", xCenter - clockRadius + 3, yCenter + 5);
        g.drawString("3", xCenter + clockRadius - 10, yCenter + 3);
        g.drawString("6", xCenter - 3, yCenter + clockRadius - 3);

        // Draw second hand
        int sLength = (int)(clockRadius * 0.8);
        int xSecond = (int)(xCenter + sLength *
                Math.sin(second * (2 * Math.PI / 60)));
        int ySecond = (int)(yCenter - sLength *
                Math.cos(second * (2 * Math.PI / 60)));
        g.setColor(Color.red);
        g.drawLine(xCenter, yCenter, xSecond, ySecond);

        // Draw minute hand
        int mLength = (int)(clockRadius * 0.65);
        int xMinute = (int)(xCenter + mLength *
                Math.sin(minute * (2 * Math.PI / 60)));
        int yMinute = (int)(yCenter - mLength *
                Math.cos(minute * (2 * Math.PI / 60)));
        g.setColor(Color.blue);
        g.drawLine(xCenter, yCenter, xMinute, yMinute);

        // Draw hour hand
        int hLength = (int)(clockRadius * 0.5);
        int xHour = (int)(xCenter + hLength *
                Math.sin((hour % 12 + minute / 60.0) * (2 * Math.PI / 12)));
        int yHour = (int)(yCenter - hLength *
                Math.cos((hour % 12 + minute / 60.0) * (2 * Math.PI / 12)));
        g.setColor(Color.green);
        g.drawLine(xCenter, yCenter, xHour, yHour);
    }

    public void setCurrentTime() {
        // Construct a calendar for the current date and time
        Calendar calendar = new GregorianCalendar();

        // Set current hour, minute and second
        this.hour = calendar.get(Calendar.HOUR_OF_DAY);
        this.minute = calendar.get(Calendar.MINUTE);
        this.second = calendar.get(Calendar.SECOND);
    }

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

所以我的问题是如何让风扇和时钟同时旋转？

这是运行代码 enter image description here 的样子

Answer 1

所以，您实际上是在问两个问题:

1. 如何为多个对象设置动画
2. 如何旋转对象(因为时钟不需要旋转)

旋转

旋转在 2D 图形中相对容易，有许多可能的选项。我将根据个人喜好使用 AffineTransform。

我们需要向 ArcsPanel 添加一些内容，我们需要一个 angle(表示当前旋转角度)和一个 delta，表示每个动画 channel 的移动量...

public static class ArcsPanel extends JPanel {

    protected static final float DELTA = 1.0f;
    private float angle = 0;

有了这些信息，我们可以简单地修改 paintComponent 方法以支持 angle 属性并应用 AffineTransform

@Override
protected void paintComponent(Graphics g) {
    super.paintComponent(g);

    Graphics2D g2d = (Graphics2D) g.create();

    int xCenter = getWidth() / 2;
    int yCenter = getHeight() / 2;
    int radius = (int) (Math.min(getWidth(), getHeight()) * 0.4);

    g2d.setTransform(AffineTransform.getRotateInstance(Math.toRadians(angle), xCenter, yCenter));

    int x = xCenter - radius;
    int y = yCenter - radius;

    g2d.fillArc(x, y, 2 * radius, 2 * radius, 0, 30);
    g2d.fillArc(x, y, 2 * radius, 2 * radius, 90, 30);
    g2d.fillArc(x, y, 2 * radius, 2 * radius, 180, 30);
    g2d.fillArc(x, y, 2 * radius, 2 * radius, 270, 30);
    g2d.dispose();
}

对多个对象进行动画处理

不管你怎么想，你并不想要更多的线程，你实际上只想要一个。这一线程将通知您想要更新的所有对象，它们应该更新其可动画状态。该线程不关心他们“如何”做到这一点，它只驱动进程。同样，您的对象并不关心引擎“如何”工作，只关心引擎会定期通知它们。

现在，Swing 既是单线程的，又不是线程安全的。这在处理线程时会引发许多问题。您不能在事件调度线程的上下文中运行长时间运行或阻塞操作，也不应该从 EDT 外部更新 UI 的状态。

为了简单起见，Swing Timer 是一个完美的选择，因为它会等待 EDT，但会在 EDT 中触发更新。

首先，我们需要某种方式让引擎告诉其他对象它们应该更新自己。当然，您可以简单地维护对其他组件的直接引用，但这既增加了对象之间的耦合，也限制了引擎的可重用性。

相反，我们定义一个简单的接口(interface)...

public interface Animatable {
    public void updateAnimatedState();
}

所有想要被通知的对象都会实现这个接口(interface)并且可以向引擎注册

public class Engine {

    private List<Animatable> animatables;
    private Timer timer;

    public Engine() {
        animatables = new ArrayList<>(4);
        timer = new Timer(10, new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                for (Animatable animatable : animatables) {
                    animatable.updateAnimatedState();
                }
            }
        });
    }

    public void add(Animatable animatable) {
        animatables.add(animatable);
    }

    public void start() {
        timer.start();
    }

    public void stop() {
        timer.stop();
    }
}

现在，我们需要做的就是更新这两个组件......

public static class ArcsPanel extends JPanel implements Animatable {
    //...
    @Override
    public void updateAnimatedState() {
        angle += DELTA;
        repaint();
    }
}

public class StillClock extends JPanel implements Animatable {
    //...

    @Override
    public void updateAnimatedState() {
        setCurrentTime();
        repaint();
    }
}

您会注意到，我稍微修改了您的代码，以便两个组件现在都从 JPanel 扩展，从 JFrame 扩展非常有限，通常不鼓励。

最后，我们只需要把它全部设置好...

public class Test {

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

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

                ArcsPanel arcPanel = new ArcsPanel();
                StillClock clockPanel = new StillClock();

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setLayout(new GridLayout(0, 2));
                frame.add(arcPanel);
                frame.add(clockPanel);
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);

                Engine engine = new Engine();
                engine.add(arcPanel);
                engine.add(clockPanel);
                engine.start();
            }
        });
    }
}

可运行示例...

因为我知道一堆脱离上下文的代码片段是多么令人困惑......

import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.geom.AffineTransform;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.GregorianCalendar;
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 Test {

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

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

                ArcsPanel arcPanel = new ArcsPanel();
                StillClock clockPanel = new StillClock();

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setLayout(new GridLayout(0, 2));
                frame.add(arcPanel);
                frame.add(clockPanel);
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);

                Engine engine = new Engine();
                engine.add(arcPanel);
                engine.add(clockPanel);
                engine.start();
            }
        });
    }

    public class Engine {

        private List<Animatable> animatables;
        private Timer timer;

        public Engine() {
            animatables = new ArrayList<>(4);
            timer = new Timer(10, new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    for (Animatable animatable : animatables) {
                        animatable.updateAnimatedState();
                    }
                }
            });
        }

        public void add(Animatable animatable) {
            animatables.add(animatable);
        }

        public void start() {
            timer.start();
        }

        public void stop() {
            timer.stop();
        }
    }

    public interface Animatable {

        public void updateAnimatedState();
    }

    public static class ArcsPanel extends JPanel implements Animatable {

        protected static final float DELTA = 1.0f;
        private float angle = 0;

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

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);

            Graphics2D g2d = (Graphics2D) g.create();

            int xCenter = getWidth() / 2;
            int yCenter = getHeight() / 2;
            int radius = (int) (Math.min(getWidth(), getHeight()) * 0.4);

            g2d.setTransform(AffineTransform.getRotateInstance(Math.toRadians(angle), xCenter, yCenter));

            int x = xCenter - radius;
            int y = yCenter - radius;

            g2d.fillArc(x, y, 2 * radius, 2 * radius, 0, 30);
            g2d.fillArc(x, y, 2 * radius, 2 * radius, 90, 30);
            g2d.fillArc(x, y, 2 * radius, 2 * radius, 180, 30);
            g2d.fillArc(x, y, 2 * radius, 2 * radius, 270, 30);
            g2d.dispose();
        }

        @Override
        public void updateAnimatedState() {
            angle += DELTA;
            repaint();
        }
    }

    public class StillClock extends JPanel implements Animatable {

        private int hour;
        private int minute;
        private int second;

        public StillClock() {
            setCurrentTime();
        }

        public StillClock(int hour, int minute, int second) {
            this.hour = hour;
            this.minute = minute;
            this.second = second;
        }

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

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);

            // Initialize clock parameters
            int clockRadius
                            = (int) (Math.min(getWidth(), getHeight()) * 0.8 * 0.5);
            int xCenter = getWidth() / 2;
            int yCenter = getHeight() / 2;

            // Draw circle
            g.setColor(Color.black);
            g.drawOval(xCenter - clockRadius, yCenter - clockRadius,
                            2 * clockRadius, 2 * clockRadius);
            g.drawString("12", xCenter - 5, yCenter - clockRadius + 12);
            g.drawString("9", xCenter - clockRadius + 3, yCenter + 5);
            g.drawString("3", xCenter + clockRadius - 10, yCenter + 3);
            g.drawString("6", xCenter - 3, yCenter + clockRadius - 3);

            // Draw second hand
            int sLength = (int) (clockRadius * 0.8);
            int xSecond = (int) (xCenter + sLength
                            * Math.sin(second * (2 * Math.PI / 60)));
            int ySecond = (int) (yCenter - sLength
                            * Math.cos(second * (2 * Math.PI / 60)));
            g.setColor(Color.red);
            g.drawLine(xCenter, yCenter, xSecond, ySecond);

            // Draw minute hand
            int mLength = (int) (clockRadius * 0.65);
            int xMinute = (int) (xCenter + mLength
                            * Math.sin(minute * (2 * Math.PI / 60)));
            int yMinute = (int) (yCenter - mLength
                            * Math.cos(minute * (2 * Math.PI / 60)));
            g.setColor(Color.blue);
            g.drawLine(xCenter, yCenter, xMinute, yMinute);

            // Draw hour hand
            int hLength = (int) (clockRadius * 0.5);
            int xHour = (int) (xCenter + hLength
                            * Math.sin((hour % 12 + minute / 60.0) * (2 * Math.PI / 12)));
            int yHour = (int) (yCenter - hLength
                            * Math.cos((hour % 12 + minute / 60.0) * (2 * Math.PI / 12)));
            g.setColor(Color.green);
            g.drawLine(xCenter, yCenter, xHour, yHour);
        }

        public void setCurrentTime() {
            // Construct a calendar for the current date and time
            Calendar calendar = new GregorianCalendar();

            // Set current hour, minute and second
            this.hour = calendar.get(Calendar.HOUR_OF_DAY);
            this.minute = calendar.get(Calendar.MINUTE);
            this.second = calendar.get(Calendar.SECOND);
        }

        @Override
        public void updateAnimatedState() {
            setCurrentTime();
            repaint();
        }
    }
}