Java GUI动画：动作类和更改类之间的滑块值？

我的GUI框架现在出现了，但是我从滑块中获得的滑块值（速度）没有出现在ActionListener类中，我需要将其用作计时器中的延迟。我如何实现这个价值？关键是运行12幅图像，就像帧一样，速度由它们滑动的值决定。如果它们滑到12，每个图像之间将有12毫秒

import javax.swing.*;
import java.awt.event.*;
import javax.swing.event.*;
import java.awt.*;

public class SliderGUI {

    public static JSlider slider = new JSlider(JSlider.HORIZONTAL, 0, 100, 1);
    public static JLabel label = new JLabel ();
    public static JPanel panel = new JPanel();
    public static int delay;
    public static int speed;
    public static ImageIcon imageIcon;
    public static Timer timer = new Timer (delay, new SliderListener());

    public static void main(String[] args) {    
        JFrame frame = new JFrame("Legend Of Zelda");
        panel.setLayout(new GridLayout(5, 5, 5, 25));
        slider.setPaintLabels(true);
        slider.addChangeListener(new SliderListener());
        System.out.println (speed);
        timer.addActionListener (new SliderListener());

        frame.setVisible(true);
        frame.setResizable(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        panel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
        panel.setLayout(new BoxLayout(panel, BoxLayout.PAGE_AXIS));

        panel.add(label);
        panel.add(slider);
        frame.setContentPane(panel);
        frame.pack();
    }

    private static class SliderListener implements ChangeListener, ActionListener {

        public void stateChanged(ChangeEvent e) {
            speed = slider.getValue();
            slider.setMajorTickSpacing(25);

        }

        public void actionPerformed (ActionEvent e) {
            for (int i = 1; i < 13; i++) {
                if (i == 12){
                    i = 1;
                }
                imageIcon = new ImageIcon(i + ".jpg");
                label.setIcon(imageIcon);
            }
            System.out.println ("Hi");
            timer = new Timer(speed, new SliderListener());
            timer.start();
        }
    }
}

import javax.swing.*；
导入java.awt.event.*；
导入javax.swing.event.*；
导入java.awt.*；
公共类SliderGUI{
公共静态JSlider滑块=新JSlider（JSlider.HORIZONTAL，0,100,1）；
公共静态JLabel标签=新JLabel（）；
publicstaticjpanel面板=newjpanel（）；
公共静态输入延迟；
公共静态整数速度；
公共静态图像图标；
公共静态计时器=新计时器（延迟，新的SliderListener（））；
公共静态void main（字符串[]args）{
JFrame=新JFrame（“塞尔达传奇”）；
面板设置布局（新网格布局（5,5,5,25））；
slider.setPaintLabels（true）；
addChangeListener（新的SliderListener（））；
System.out.println（速度）；
timer.addActionListener（新的SliderListener（））；
frame.setVisible（true）；
frame.setresizeable（true）；
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
panel.setBorder（BorderFactory.createEmptyByOrder（10,10,10,10））；
panel.setLayout（新的BoxLayout（panel，BoxLayout.PAGE_轴））；
面板。添加（标签）；
面板。添加（滑块）；
frame.setContentPane（面板）；
frame.pack（）；
}
私有静态类SliderListener实现ChangeListener、ActionListener{
公共无效状态已更改（更改事件e）{
速度=slider.getValue（）；
滑块。设置主轨迹间距（25）；
}
已执行的公共无效操作（操作事件e）{
对于（int i=1；i<13；i++）{
如果（i==12）{
i=1；
}
imageIcon=新的imageIcon（i+“.jpg”）；
label.setIcon（图像图标）；
}
System.out.println（“Hi”）；
定时器=新定时器（速度，新的SliderListener（））；
timer.start（）；
}
}
}
不要依赖于
静态
，它会在你面前爆炸

您正在创建多个实例
SliderListener
，而实际上您应该只创建一个实例，并将其应用于
JSlider
（在您的情况下）计时器

话虽如此，我（个人）还是把他们分开

每次调用
ActionListener
时，您也会创建一个新的
计时器（就像每秒一千次！因此1秒后，您可以运行1001个
计时器！），所有这些计时器都将同时调用
SliderListener
，因为它都是通过全局变量连接的…面对爆炸

但我实际上没有看到你在哪里陈述开始时的
计时器

import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;
import javax.swing.BorderFactory;
import javax.swing.BoxLayout;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSlider;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

public class SliderGUI {

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

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

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

    public class TestPane extends JPanel {

        public JSlider slider = new JSlider(JSlider.HORIZONTAL, 10, 100, 10);
        public JLabel label;
        public int delay;
        public int speed;
        public ImageIcon imageIcon;
        public Timer timer;

        public TestPane() {
            setLayout(new GridLayout(5, 5, 5, 25));
            slider.setPaintLabels(true);

            label = new JLabel();
            try {
                BufferedImage frameImage = ImageIO.read(getClass().getResource("/Run-0.png"));
                label.setIcon(new ImageIcon(frameImage));
            } catch (IOException ex) {
                ex.printStackTrace();
            }

            SliderListener sliderListener = new SliderListener();
            timer = new Timer(delay, sliderListener);
            slider.addChangeListener(sliderListener);
            System.out.println(speed);
            timer.addActionListener(sliderListener);

            timer.start();

            setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
            setLayout(new BoxLayout(this, BoxLayout.PAGE_AXIS));

            add(label);
            add(slider);
        }

        private class SliderListener implements ChangeListener, ActionListener {

            public void stateChanged(ChangeEvent e) {

                int value = slider.getValue();
                timer.setDelay(value);

            }

            private int frame = 0;

            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("Tick " + ((Timer) e.getSource()).getDelay());
                try {
                    BufferedImage frameImage = ImageIO.read(getClass().getResource("/Run-" + frame + ".png"));
                    label.setIcon(new ImageIcon(frameImage));
                } catch (IOException exp) {
                    exp.printStackTrace();
                }
                frame++;
                if (frame > 11) {
                    frame = 0;
                }
            }
        }

    }

}


另外，请记住，
计时器
就像一个循环，每次调用
ActionListener
时，您都应该将其视为循环的一次迭代，并相应地更新状态…
除非有什么东西改变它，否则它不会出现…问自己这个问题，设置为
计时器的
SliderListener
实例与设置为
JSlider
的实例之间有什么关系？它们都在同一个类下？但是，它们是不同的实例…不依赖于
静态
。编程101-全局变量是个坏主意