Erro ao compilar um Applet

Olá pessoal, eu sou iniciante na linguagem java e estou tentando criar um Applet, porém está ocorrendo um erro na hora de compilar o Applet. O código do Applet é o seguinte colocarei logo abaixo. O erro está ocorrendo no seguinte trecho do Applet:

_thread = new Thread( this );

Se alguém pudesse me ajudar eu agradeceria muito, pois não faço idéia, pois peguei o Applet na net, na página do desenvolvedor ele funciona e o código é open source

                                                                                  O código é o seguinte:

[code]package de.kclee.dla

import java.applet.Applet
import java.awt.Color
import java.awt.Graphics
import java.util.Random

public class DLAApplet extends Applet implements Runnable
{
private static final int _appletWidth = 640;
private static final int _appletHeight = 480;
private static final int POINTS = 40000;
private int _dlaPoints = 0;
private Random _random = new Random();
private static final int RED = 255;
private static final int BLUE = 0;
private static final int INITIAL_GREEN = 0;
private static final int INITIAL_COLOR_DIRECTION = 1;
private int[] _aX = new int[ POINTS ];
private int[] _aY = new int[ POINTS ];
private int[][] _aScreen = new int[ _appletWidth ][ _appletHeight ];
private static final int EMPTY = -1;
private static final int POINT = -2;
private static final int DLA = 0;
private Thread _thread = null;
private boolean _active = false;
private static final int UP = 0;
private static final int RIGHT = 1;
private static final int DOWN = 2;
private static final int LEFT = 3;

private int _increaseX( int x )
{
    return _increase( x, _appletWidth );
}

private int _increaseY( int y )
{
    return _increase( y, _appletHeight );
}

private int _increase( int x, int limit )
{
    int retVal = x + 1;
    if ( retVal >= limit )
        {
            retVal = 0;
        }
    
    return retVal;
}

private int _decreaseX( int x )
{
    return _decrease( x, _appletWidth );
}

private int _decreaseY( int y )
{
    return _decrease( y, _appletHeight );
}

private int _decrease( int x, int limit )
{
    int retVal = x - 1;
    if ( retVal < 0 )
        {
            retVal = limit - 1;
        }
    
    return retVal;
}

private int nextGreen( int green, int direction )
{
    int retVal = green + direction;
    if ( retVal < 0 || retVal >= 256 )
        {
            return nextGreen( retVal, -direction );
        }

    return retVal;
}

private int nextDirection( int green, int direction )
{
    int newGreen = green + direction;
    if ( newGreen < 0 || newGreen >= 256 )
        {
            return -direction;
        }

    return direction;
}

private int colorDirectionOffset( int direction )
{
    return 512 + direction * 256;
}

public void init()
{
    setBackground ( Color.black );

    for( int x = 0; x < _appletWidth; x++ )
        {
            for( int y = 0; y < _appletHeight; y++ )
                {
                    _aScreen[ x ][ y ] = EMPTY;
                }
        }

    int middleX = _appletWidth / 2;
    int middleY = _appletHeight / 2;
    _aX[ _dlaPoints ] = middleX;
    _aY[ _dlaPoints ] = middleY;
    _aScreen[ _aX[ _dlaPoints ] ][ _aY[ _dlaPoints ] ] = INITIAL_GREEN + colorDirectionOffset( INITIAL_COLOR_DIRECTION );
    _dlaPoints++;

    for( int i = _dlaPoints; i < POINTS; i++ )
        {
            do
                {
                    _aX[ i ] = _random.nextInt( _appletWidth );
                    _aY[ i ] = _random.nextInt( _appletHeight );
                }
            while( _aScreen[ _aX[ i ] ][ _aY[ i ] ] != EMPTY );
            _aScreen[ _aX[ i ] ][ _aY[ i ] ] = POINT;
        }

    _thread = new Thread( this );
}

private int getGreen( int point )
{
    return _aScreen[ _aX[ point ] ][ _aY[ point ] ] % 256;
}

synchronized public void paint(Graphics g)
{
    // print dla
    for( int i = 0; i < _dlaPoints; i++ )
        {
            g.setColor( new Color( RED, getGreen( i ), BLUE ) );
            g.drawLine( _aX[ i ], _aY[ i ], _aX[ i ], _aY[ i ] );
        }

    // draw initial points
    g.setColor( Color.yellow );
    for( int i = _dlaPoints; i < POINTS; i++ )
        {
            g.drawLine( _aX[ i ], _aY[ i ], _aX[ i ], _aY[ i ] );
        }
}

synchronized public void update(Graphics g)
{
    if ( _active && _dlaPoints == POINTS )
        {
            _active = false;

            return;
        }
    
    for( int i = _dlaPoints; i < POINTS; i++ )
        {
            // is there a dla point next to this one?
            int previousGreenAndDirection = EMPTY;
            if ( _aScreen[ _aX[ i ] ][ _decreaseY( _aY[ i ] ) ] >= DLA )
                {
                    previousGreenAndDirection = _aScreen[ _aX[ i ] ][ _decreaseY( _aY[ i ] ) ];
                }
            else if ( _aScreen[ _increaseX( _aX[ i ] ) ][ _aY[ i ] ] >= DLA )
                        {
                            previousGreenAndDirection = _aScreen[ _increaseX( _aX[ i ] ) ][ _aY[ i ] ];
                        }
            else if ( _aScreen[ _aX[ i ] ][ _increaseY( _aY[ i ] ) ] >= DLA )
                {
                    previousGreenAndDirection = _aScreen[ _aX[ i ] ][ _increaseY( _aY[ i ] ) ];
                }
            else if ( _aScreen[ _decreaseX( _aX[ i ] ) ][ _aY[ i ] ] >= DLA )
                {
                    previousGreenAndDirection = _aScreen[ _decreaseX( _aX[ i ] ) ][ _aY[ i ] ];
                }
            if ( previousGreenAndDirection >= DLA )
                {
                    int previousGreen = previousGreenAndDirection % 256;
                    int previousDirection = (previousGreenAndDirection / 256) - 2;
                    int nextGreen = nextGreen( previousGreen, previousDirection );
                    int nextDirection = nextDirection( previousGreen, previousDirection );
                    _aScreen[ _aX[ i ] ][ _aY[ i ] ] = nextGreen + colorDirectionOffset( nextDirection );
                    g.setColor( new Color( RED, nextGreen, BLUE ) );
                    g.drawLine( _aX[ i ], _aY[ i ], _aX[ i ], _aY[ i ] );
                    int otherX = _aX[ _dlaPoints ];
                    int otherY = _aY[ _dlaPoints ];
                    _aX[ _dlaPoints ] = _aX[ i ];
                    _aY[ _dlaPoints ] = _aY[ i ];
                    _aX[ i ] = otherX;
                    _aY[ i ] = otherY;
                    _dlaPoints ++;
                    
                    continue;
                }

            // random walk
            int direction = _random.nextInt( 4 );
            if ( direction == UP )
                {
                    if ( _aScreen[ _aX[ i ] ][ _decreaseY( _aY[ i ] ) ] == EMPTY )
                        {
                            _aScreen[ _aX[ i ] ][ _aY[ i ] ] = EMPTY;
                            g.setColor( Color.black );
                            g.drawLine( _aX[ i ], _aY[ i ], _aX[ i ], _aY[ i ] );
                            _aY[ i ] = _decreaseY( _aY[ i ] );
                            _aScreen[ _aX[ i ] ][ _aY[ i ] ] = POINT;
                            g.setColor( Color.yellow );
                            g.drawLine( _aX[ i ], _aY[ i ], _aX[ i ], _aY[ i ] );
                        }
                }
            else if ( direction == DOWN )
                {
                    if ( _aScreen[ _aX[ i ] ][ _increaseY( _aY[ i ] ) ] == EMPTY )
                        {
                            _aScreen[ _aX[ i ] ][ _aY[ i ] ] = EMPTY;
                            g.setColor( Color.black );
                            g.drawLine( _aX[ i ], _aY[ i ], _aX[ i ], _aY[ i ] );
                            _aY[ i ] = _increaseY( _aY[ i ] );
                            _aScreen[ _aX[ i ] ][ _aY[ i ] ] = POINT;
                            g.setColor( Color.yellow );
                            g.drawLine( _aX[ i ], _aY[ i ], _aX[ i ], _aY[ i ] );
                        }
                }
            else if ( direction == RIGHT )
                {
                    if ( _aScreen[ _increaseX( _aX[ i ] ) ][ _aY[ i ] ] == EMPTY )
                        {
                            _aScreen[ _aX[ i ] ][ _aY[ i ] ] = EMPTY;
                            g.setColor( Color.black );
                            g.drawLine( _aX[ i ], _aY[ i ], _aX[ i ], _aY[ i ] );
                            _aX[ i ] = _increaseX( _aX[ i ] );
                            _aScreen[ _aX[ i ] ][ _aY[ i ] ] = POINT;
                            g.setColor( Color.yellow );
                            g.drawLine( _aX[ i ], _aY[ i ], _aX[ i ], _aY[ i ] );
                        }
                }
            else if ( direction == LEFT )
                {
                    if ( _aScreen[ _decreaseX( _aX[ i ] ) ][ _aY[ i ] ] == EMPTY )
                        {
                            _aScreen[ _aX[ i ] ][ _aY[ i ] ] = EMPTY;
                            g.setColor( Color.black );
                            g.drawLine( _aX[ i ], _aY[ i ], _aX[ i ], _aY[ i ] );
                            _aX[ i ] = _decreaseX( _aX[ i ] );
                            _aScreen[ _aX[ i ] ][ _aY[ i ] ] = POINT;
                            g.setColor( Color.yellow );
                            g.drawLine( _aX[ i ], _aY[ i ], _aX[ i ], _aY[ i ] );
                        }
                }
        }
}

public String getAppletInfo()
{
    return "DLA Applet by Chr. Clemens Lee [2005-03-25]";
}

public void start()
{
    _active = true;
    _thread.start();
}

public void stop()
{
    _active = false;
}

public void run()
{
    while( _active )
        {
            repaint();
            _thread.yield();
        }
}

}[/code]