Java小程序无法在浏览器中加载

我正在尝试让一个小程序加载到网页上，但它无法正确加载。以下是页面的小程序标记：

<applet codebase="classes" code="Simulation.class" width="600" height="600"></applet>

）。小程序需要其他类，但它们仍然都在“classes”目录下，所以我认为这不是问题所在。以下是Simulation.java文件的代码：

import java.applet.Applet;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.text.DecimalFormat;
import java.util.ArrayList;

public class Simulation 
    extends Applet 
    implements Runnable, MouseListener, MouseMotionListener, KeyListener{

private static final long serialVersionUID = -1914559969027349635L;

private boolean threadSuspended;
private Thread t = null;
private int startX;
private int startY;
private int endX;
private int endY;

private Environment env;
private int numAgents = -1;
private int width;
private int height;
private int stepTime;
private int currentParam;
private boolean start;
private boolean instructions;

private final double START_RANGE = 70.0;
private final double START_BUFFER = 5.0;
private int speed;
private final int[] SPEEDS = {4, 5, 6, 7, 8, 
                              10, 12, 15, 18, 22, 
                              26, 30, 35, 40, 50, 
                              65, 80, 100, 150, 300};

public void init() {
    start = true;
    currentParam = 1;
    initParams();
    env = new Environment(width, height, numAgents, START_RANGE, START_BUFFER);
    env.init();
    resize(width, height);
    setBackground(Color.WHITE);
    addMouseListener(this);
    addMouseMotionListener(this);
    addKeyListener(this);
    repaint();
}

public void restart() {
    stop();
    start = true;
    double tempVD = env.getVelocityDiscount();
    double tempHD = env.getHeadingDiscount();
    env = new Environment(width, height, numAgents, env.getRange(), env.getBuffer());
    env.init();
    env.setVelocityDiscount(tempVD);
    env.setHeadingDiscount(tempHD);
    repaint();
}

private void initParams() {
    start = true;
    width = 600;
    height = 600;
    stepTime = 15;
    speed = 8;
    getNumAgents();
}

private void getNumAgents() {
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    try {
        if (numAgents < 1) {
            System.out.print("Number of agents: ");
            numAgents = Integer.parseInt(reader.readLine());
        }
    }
    catch (Exception e) {
        System.err.println("Error reading input. Please enter only positive integers.");
        try {
            Thread.sleep(500);
        } catch (InterruptedException e1) {
            System.err.println("Thread interrupted.");
            System.exit(1);
        }
        getNumAgents();
    }
    if (numAgents < 1) {
        System.err.println("Error reading input. Please enter only positive integers.");
        getNumAgents();
    }
}

public void start(){
    if (t == null){
        t = new Thread(this);
        threadSuspended = false;
        t.start();
    }
    else{
        if(threadSuspended){
            threadSuspended = false;
            synchronized(this){
                notify();
            }
        }
    }
}

public void stop(){
    threadSuspended = true;
}

public void run(){
    numAgents = env.getAgents().size();
    width = env.getWidth();
    height = env.getHeight();
    try {
        stop();
        while (true) {
            if (threadSuspended){
                synchronized(this){
                    while (threadSuspended){
                        wait();
                    }
                }
            }
            if (this.getWidth() != env.getWidth() || this.getHeight() != env.getHeight()) {
                env.setWidth(this.getWidth());
                env.setHeight(this.getHeight());
            }
            env.cycle();
            repaint();
            for (int i = 0; i < stepTime / 5; i++) {
                Thread.sleep(5);
            }
        }
    }
    catch (InterruptedException e) {
        System.err.println("Runtime Error");
        e.printStackTrace();
    }
}

public void paint(Graphics g){
    g.setFont(new Font("SansSerif", Font.PLAIN, 15));
    ArrayList<Agent> agents = env.getAgents();
    for (Agent i : agents) {
        if (i.isSelected()) {
            g.setColor(Color.RED);
            g.fillOval((int) i.getX() - 2, (int) i.getY() - 2, 5, 5);
        }
        else {
            switch (i.getGroup()) {
            case 0:
                g.setColor(Color.BLACK);
                break;
            case 1:
                g.setColor(Color.BLUE);
                break;
            case 2:
                g.setColor(Color.YELLOW);
                break;
            case 3:
                g.setColor(Color.RED);
                break;
            case 4:
                g.setColor(Color.GREEN);
                break;
            case 5:
                g.setColor(Color.ORANGE);
                break;
            case 6:
                g.setColor(Color.CYAN);
                break;
            case 7:
                g.setColor(Color.PINK);
                break;
            case 8:
                g.setColor(Color.MAGENTA);
                break;
            case 9:
                g.setColor(Color.DARK_GRAY);
                break;
            }
            g.drawOval((int) i.getX() - 1, (int) i.getY() - 1, 3, 3);
        }
    }
    if (startX != -1 && startY != -1 && endX != -1 && endY != -1) {
        g.setColor(Color.LIGHT_GRAY);
        Rectangle r = getDraggedRect();
        g.drawRect((int) r.getMinX(), (int) r.getMinY(), r.width, r.height);
    }
    g.setColor(Color.LIGHT_GRAY);
    switch (currentParam) {
    case 1:
        g.drawString("Speed: " + (SPEEDS.length - speed), 2, 12);
        break;
    case 2:
        g.drawString("Sensing range: " + env.getRange(), 2, 12);
        break;
    case 3:
        g.drawString("Velocity discount: " + env.getVelocityDiscount(), 2, 12);
        break;
    case 4:
        g.drawString("Heading discount: " + env.getHeadingDiscount(), 2, 12);
        break;
    case 5:
        g.drawString("Buffer: " + env.getBuffer(), 2, 12);
        break;
    }
    if (start || instructions) {
        drawInstructions(g);
    }
}

private void drawInstructions(Graphics g) {
    Color c = new Color(50, 50, 50, 200);
    g.setColor(c);
    int startX = (width / 2) - 152;
    int startY = (width / 2) - 152;
    g.fill3DRect(startX, startY, 304, 304, true);
    g.setColor(Color.WHITE);
    g.setFont(new Font("SansSerif", Font.PLAIN, 10));
    g.drawString("Please set parameters before starting (parameters can be", startX + 3, startY + 13);
    g.drawString("altered at any time - current selected parameter is in the", startX + 3, startY + 26);
    g.drawString("upper left corner at all times):", startX + 3, startY + 39);
    g.drawString("Press 'S' to change simulation speed", startX + 3, startY + 52);
    g.drawString("Press 'R' to change sensing range", startX + 3, startY + 65);
    g.drawString("Press 'V' to change velocity discount", startX + 3, startY + 78);
    g.drawString("Press 'H' to change header discount", startX + 3, startY + 91);
    g.drawString("Press 'B' to change buffer size", startX + 3, startY + 104);
    g.drawString("Use the UP and DOWN arrow keys to alter parameters", startX + 3, startY + 117);
    g.drawString("Press the FORWARD arrow while paused to move one step", startX + 3, startY + 143);
    g.drawString("Press SPACEBAR to pause or resume", startX + 3, startY + 156);
    g.drawString("Reset the simulation by pressing ENTER", startX + 3, startY + 169);
    g.drawString("Groups:", startX + 3, startY + 195);
    g.drawString("Assign agents to any group by pressing 0-9 when selected.", startX + 3, startY + 208);
    g.drawString("CLICK on any agent to select it, or select several agents", startX + 3, startY + 221);
    g.drawString("at once by DRAGGING a selection box around them.", startX + 3, startY + 234);
    g.drawString("Agents will only cohere to others in their group, but will", startX + 3, startY + 247);
    g.drawString("still avoid collisions with all agents in the simulation.", startX + 3, startY + 260);
    g.drawString("Press SPACEBAR to begin", startX + 3, startY + 286);
    g.setFont(new Font("SansSerif", Font.ITALIC, 10));
    g.drawString("NOTE: these instructions can be brought up by pressing i", startX + 3, startY + 299);
}

private Rectangle getDraggedRect() {
    int xS;
    int width;
    int yS;
    int height;
    if (startX > endX) {
        xS = endX;
        width = startX - endX;
    }
    else {
        xS = startX;
        width = endX - startX;
    }
    if (startY > endY) {
        yS = endY;
        height = startY - endY;
    }
    else {
        yS = startY;
        height = endY - startY;
    }
    return new Rectangle(xS - 3, yS - 3, width + 7, height + 7);
}

private double roundTwo(double d) {
    DecimalFormat twoDForm = new DecimalFormat("#.##");
    return Double.valueOf(twoDForm.format(d));
}

public void mouseClicked(MouseEvent e) {}

public void mouseEntered(MouseEvent e) {}

public void mouseExited(MouseEvent e) {}

public void mousePressed(MouseEvent e) {
    stop();
    startX = e.getX();
    startY = e.getY();
}

public void mouseReleased(MouseEvent e) {
    endX = e.getX();
    endY = e.getY();
    Rectangle r = getDraggedRect();
    Point temp;
    for (Agent i : env.getAgents()) {
        temp = new Point((int) i.getX(), (int) i.getY());
        if (r.contains(temp)) {
            i.select();
        }
        else {
            i.setSelected(false);
        }
    }
    startX = -1;
    startY = -1;
    endX = -1;
    endY = -1;
    repaint();
}

public void mouseDragged(MouseEvent e) {
    endX = e.getX();
    endY = e.getY();
    repaint();
}

public void mouseMoved(MouseEvent e) {}

public void keyPressed(KeyEvent e) {
    int code = e.getKeyCode();
    switch (code) {
    case 10:
        restart();
        break;
    case 32:
        start = false;
        if (threadSuspended) {
            start();
        }
        else {
            stop();
        }
        break;
    case 39:
        if (threadSuspended && !start) {
            env.cycle();
            repaint();
        }
        break;
    case 83:
        currentParam = 1;
        repaint();
        break;
    case 82:
        currentParam = 2;
        repaint();
        break;
    case 86:
        currentParam = 3;
        repaint();
        break;
    case 72:
        currentParam = 4;
        repaint();
        break;
    case 66:
        currentParam = 5;
        repaint();
        break;
    case 65:
        env.setAllSelected();
        repaint();
        break;
    case 73:
        if (!start) {
            instructions = !instructions;
            repaint();
        }
        break;
    case 48:
        env.setSelectedGroup(0);
        break;
    case 49:
        env.setSelectedGroup(1);
        break;
    case 50:
        env.setSelectedGroup(2);
        break;
    case 51:
        env.setSelectedGroup(3);
        break;
    case 52:
        env.setSelectedGroup(4);
        break;
    case 53:
        env.setSelectedGroup(5);
        break;
    case 54:
        env.setSelectedGroup(6);
        break;
    case 55:
        env.setSelectedGroup(7);
        break;
    case 56:
        env.setSelectedGroup(8);
        break;
    case 57:
        env.setSelectedGroup(9);
        break;
    }
    switch (currentParam) {
    case 1:
        if (code == 38 && speed > 0) {
            speed--;
            stepTime = SPEEDS[speed];
            repaint();
        }
        if (code == 40 && speed < SPEEDS.length - 1) {
            speed++;
            stepTime = SPEEDS[speed];
            repaint();
        }
        break;
    case 2:
        if (code == 38 && env.getRange() < 200) {
            env.setRange(env.getRange() + 5);
            repaint();
        }
        if (code == 40 && env.getRange() > 5) {
            env.setRange(env.getRange() - 5);
            repaint();
        }
        break;
    case 3:
        if (code == 38 && env.getVelocityDiscount() < 0.99) {
            env.setVelocityDiscount(roundTwo(env.getVelocityDiscount() + 0.01));
            repaint();
        }
        if (code == 40 && env.getVelocityDiscount() > 0.00) {
            env.setVelocityDiscount(roundTwo(env.getVelocityDiscount() - 0.01));
            repaint();
        }
        break;
    case 4:
        if (code == 38 && env.getHeadingDiscount() < 0.99) {
            env.setHeadingDiscount(roundTwo(env.getHeadingDiscount() + 0.01));
            repaint();
        }
        if (code == 40 && env.getHeadingDiscount() > 0.01) {
            env.setHeadingDiscount(roundTwo(env.getHeadingDiscount() - 0.01));
            repaint();
        }
        break;
    case 5:
        if (code == 38 && env.getBuffer() < 100) {
            env.setBuffer(env.getBuffer() + 5);
            repaint();
        }
        if (code == 40 && env.getBuffer() > 0) {
            env.setBuffer(env.getBuffer() - 5);
            repaint();
        }
        break;
    }
}

public void keyReleased(KeyEvent e) {}

public void keyTyped(KeyEvent e) {}
}

import java.applet.applet；
导入java.awt.Color；
导入java.awt.Font；
导入java.awt.Graphics；
导入java.awt.Point；
导入java.awt.Rectangle；
导入java.awt.event.KeyEvent；
导入java.awt.event.KeyListener；
导入java.awt.event.MouseEvent；
导入java.awt.event.MouseListener；
导入java.awt.event.MouseMotionListener；
导入java.io.BufferedReader；
导入java.io.InputStreamReader；
导入java.text.DecimalFormat；
导入java.util.ArrayList；
公共类模拟
扩展小程序
实现Runnable、MouseListener、MouseMotionListener、KeyListener{
私有静态最终长serialVersionUID=-1914559969027349635L；
私有布尔值被暂停；
私有线程t=null；
私人int startX；
私人int startY；
私有内部端点；
私人内部；
私人环境署；
私有整数整数=-1；
私有整数宽度；
私人内部高度；
私人时间；
私有int-currentParam；
私有布尔启动；
私有布尔指令；
私人最终双启动范围=70.0；
专用最终双启动缓冲区=5.0；
私人整数速度；
私人最终整数[]速度={4,5,6,7,8，
10, 12, 15, 18, 22, 
26, 30, 35, 40, 50, 
65, 80, 100, 150, 300};
公共void init（）{
开始=真；
currentParam=1；
initParams（）；
env=新环境（宽度、高度、亮度、起始范围、起始缓冲区）；
env.init（）；
调整大小（宽度、高度）；
挫折地面（颜色：白色）；
addMouseListener（这个）；
addMouseMotionListener（此）；
addKeyListener（此）；
重新油漆（）；
}
公共无效重新启动（）{
停止（）；
开始=真；
double tempVD=env.getVelocityDiscount（）；
double tempHD=env.getHeadingDiscount（）；
env=新环境（宽度、高度、numAgents、env.getRange（）、env.getBuffer（））；
env.init（）；
环境设置速度偏差（临时偏差）；
环境设定折扣（临时折扣）；
重新油漆（）；
}
私有void initParams（）{
开始=真；
宽度=600；
高度=600；
步进时间=15；
速度=8；
getNumAgents（）；
}
私有void getNumAgents（）{
BufferedReader reader=新的BufferedReader（新的InputStreamReader（System.in））；
试一试{
如果（数值小于1）{
系统输出打印（“代理数量：”）；
numAgents=Integer.parseInt（reader.readLine（））；
}
}
捕获（例外e）{
System.err.println（“读取输入时出错。请只输入正整数”）；
试一试{
睡眠（500）；
}捕捉（中断异常e1）{
System.err.println（“线程中断”）；
系统出口（1）；
}
getNumAgents（）；
}
如果（数值小于1）{
System.err.println（“读取输入时出错。请只输入正整数”）；
getNumAgents（）；
}
}
公开作废开始（）{
如果（t==null）{
t=新螺纹（本螺纹）；
threadSuspended=false；
t、 start（）；
}
否则{
如果（暂停）{
threadSuspended=false；
已同步（此）{
通知（）；
}
}
}
}
公共停车场（）{
threadSuspended=true；
}
公开募捐{
numAgents=env.getAgents（）.size（）；
width=env.getWidth（）；
height=env.getHeight（）；
试一试{
停止（）；
while（true）{
如果（暂停）{
已同步（此）{
同时（暂停）{
等待（）；
}
}
}
如果（this.getWidth（）！=env.getWidth（）| | this.getHeight（）！=env.getHeight（））{
env.setWidth（this.getWidth（））；
env.setHeight（this.getHeight（））；
}
环境周期（）；
重新油漆（）；
对于（int i=0；iprivate void getNumAgents() {
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    try {
        if (numAgents < 1) {
            System.out.print("Number of agents: ");
            numAgents = Integer.parseInt(reader.readLine());
        }
    }
...