设计一个Java应用程序，包括一个窗口类和2个线程类，一个线程类获取系统时间并在窗口的右下角实时显示，另一个线程类的任务是移动窗口上的标签，如图2-4所示。具体要求： 1）在窗口上，有一个标签“学号，姓名”（你自己的真实学号与姓名），标签的初始位置在窗口的右边界处。 2）单击“启动”按钮后，“启动”按钮变为不可用，其它3个按钮的状态变为可用，同时标签“学号，姓名”从右到左不停移动，当到达左边窗口边界时，再从右边界处从右到左移动，类似学院门口的LED显示屏，如图2-5所示。 3）标签移动过程中，可以单击“加速”和“减速”按钮，进行标签移动速度控制；单击“停止”按钮时，标签停止移动，同时4个按钮恢复到初始状态，

好的，我可以为您解答这个问题。以下是一个简单的Java应用程序，包括一个窗口类和两个线程类，一个线程类获取系统时间并在窗口的右下角实时显示，另一个线程类的任务是移动窗口上的标签。

首先，我们需要创建一个窗口类，代码如下：

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

public class MyWindow extends JFrame {
    private JLabel label;
    private JButton startButton, stopButton, speedUpButton, speedDownButton;
    private Thread timeThread, labelThread;

    public MyWindow() {
        super("MyWindow");

        // 设置窗口大小和位置
        setSize(400, 200);
        setLocationRelativeTo(null);

        // 创建标签
        label = new JLabel("学号，姓名", JLabel.RIGHT);
        label.setFont(new Font("宋体", Font.BOLD, 20));
        getContentPane().add(label, BorderLayout.CENTER);

        // 创建按钮
        startButton = new JButton("启动");
        stopButton = new JButton("停止");
        speedUpButton = new JButton("加速");
        speedDownButton = new JButton("减速");

        // 添加按钮到窗口
        JPanel buttonPanel = new JPanel();
        buttonPanel.add(startButton);
        buttonPanel.add(stopButton);
        buttonPanel.add(speedUpButton);
        buttonPanel.add(speedDownButton);
        getContentPane().add(buttonPanel, BorderLayout.SOUTH);

        // 设置按钮状态
        stopButton.setEnabled(false);
        speedUpButton.setEnabled(false);
        speedDownButton.setEnabled(false);

        // 添加按钮事件处理程序
        startButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                startButton.setEnabled(false);
                stopButton.setEnabled(true);
                speedUpButton.setEnabled(true);
                speedDownButton.setEnabled(true);

                // 创建并启动线程
                timeThread = new TimeThread();
                labelThread = new LabelThread();
                timeThread.start();
                labelThread.start();
            }
        });

        stopButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                startButton.setEnabled(true);
                stopButton.setEnabled(false);
                speedUpButton.setEnabled(false);
                speedDownButton.setEnabled(false);

                // 停止线程
                timeThread.interrupt();
                labelThread.interrupt();
            }
        });

        speedUpButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                // 加速标签移动
                LabelThread.speedUp();
            }
        });

        speedDownButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                // 减速标签移动
                LabelThread.speedDown();
            }
        });

        // 关闭窗口时退出程序
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

    // 线程类：获取系统时间并在窗口的右下角实时显示
    private class TimeThread extends Thread {
        public void run() {
            try {
                while (true) {
                    String time = new java.util.Date().toString();
                    setTitle(time);
                    Thread.sleep(1000); // 每隔1秒更新一次时间
                }
            } catch (InterruptedException e) {
                return;
            }
        }
    }

    // 线程类：移动窗口上的标签
    private static class LabelThread extends Thread {
        private static int speed = 10; // 标签移动速度
        private static boolean stop = false; // 是否停止标签移动
        private static boolean reverse = false; // 是否反向移动标签

        public void run() {
            try {
                while (true) {
                    int x = MyWindow.this.getWidth() - label.getWidth() - 10;
                    int y = MyWindow.this.getHeight() - label.getHeight() - 10;
                    if (!reverse) {
                        for (int i = MyWindow.this.getWidth() - 10; i >= -label.getWidth() + 10; i -= speed) {
                            if (stop) {
                                return;
                            }
                            label.setLocation(i, y);
                            Thread.sleep(50); // 标签移动间隔
                        }
                    } else {
                        for (int i = -label.getWidth() + 10; i <= MyWindow.this.getWidth() - 10; i += speed) {
                            if (stop) {
                                return;
                            }
                            label.setLocation(i, y);
                            Thread.sleep(50); // 标签移动间隔
                        }
                    }
                    reverse = !reverse;
                }
            } catch (InterruptedException e) {
                return;
            }
        }

        public static void speedUp() {
            speed += 5;
        }

        public static void speedDown() {
            speed -= 5;
            if (speed < 5) {
                speed = 5;
            }
        }

        public static void stopMove() {
            stop = true;
        }
    }

    public static void main(String[] args) {
        MyWindow window = new MyWindow();
        window.setVisible(true);
    }
}

在窗口类中，我们创建了一个标签和四个按钮。当单击“启动”按钮时，程序创建并启动两个线程，一个获取系统时间并在窗口的标题栏实时显示，另一个移动窗口上的标签。当单击“停止”按钮时，程序停止两个线程。当单击“加速”和“减速”按钮时，程序可以控制标签移动速度。

下面是标签移动的线程类：

// 线程类：移动窗口上的标签
private static class LabelThread extends Thread {
    private static int speed = 10; // 标签移动速度
    private static boolean stop = false; // 是否停止标签移动
    private static boolean reverse = false; // 是否反向移动标签

    public void run() {
        try {
            while (true) {
                int x = MyWindow.this.getWidth() - label.getWidth() - 10;
                int y = MyWindow.this.getHeight() - label.getHeight() - 10;
                if (!reverse) {
                    for (int i = MyWindow.this.getWidth() - 10; i >= -label.getWidth() + 10; i -= speed) {
                        if (stop) {
                            return;
                        }
                        label.setLocation(i, y);
                        Thread.sleep(50); // 标签移动间隔
                    }
                } else {
                    for (int i = -label.getWidth() + 10; i <= MyWindow.this.getWidth() - 10; i += speed) {
                        if (stop) {
                            return;
                        }
                        label.setLocation(i, y);
                        Thread.sleep(50); // 标签移动间隔
                    }
                }
                reverse = !reverse;
            }
        } catch (InterruptedException e) {
            return;
        }
    }

    public static void speedUp() {
        speed += 5;
    }

    public static void speedDown() {
        speed -= 5;
        if (speed < 5) {
            speed = 5;
        }
    }

    public static void stopMove() {
        stop = true;
    }
}

在标签移动的线程类中，我们使用了两个静态变量 `speed` 和 `stop`，分别表示标签移动速度和是否停止标签移动。在 `run` 方法中，我们使用一个无限循环来实现标签移动。当 `reverse` 为 `false` 时，标签从右到左移动；当 `reverse` 为 `true` 时，标签从左到右移动。当标签移动到窗口边界时，标签反向移动。在实现标签移动时，我们使用了 `Thread.sleep` 方法来控制标签移动的间隔。在标签移动的过程中，如果 `stop` 为 `true`，则停止标签移动。

在标签移动的线程类中，我们还使用了三个静态方法，分别实现标签移动的加速、减速和停止。这些方法可以在按钮的事件处理程序中调用，从而实现对标签移动的控制。

以上就是一个简单的Java应用程序，包括一个窗口类和两个线程类，一个线程类获取系统时间并在窗口的右下角实时显示，另一个线程类的任务是移动窗口上的标签。