Cómo programar para que salga la fecha y hora en mi sistema

import java.awt.*;
import java.lang.*;
import java.util.*;
import java.applet.*;

public class RelojDigital extends Applet implements Temporizador {
    private Timer timer;
    private Etiqueta horaActual;
    private Color fondo;

    // Este es el metodo main() para que podamos ejecutar la aplicacion
    // desde la linea de comandos
    public static void main( String args[] ) {
        RelojDigital reloj = new RelojDigital();

        reloj.init();
        reloj.start();
     
        // Craemos un frame para que se pueda visualizar el reloj
        Frame frame = new Frame( "Reloj Digital" );
        frame.add( "Center",reloj );
        frame.resize( 50,20 );
        frame.show();
        }  
     

    public void init() {
        // Cargamos el parametro que nos indica el color de fondo que
        // queremos para el reloj, si no se especifica o no se indica
        // correctamente, fijamos uno por defecto
        // Lo adecuado, en caso de presentar el applet sobre una pagina
        // de un navegador es que este parametro coincida con el que
        // se especifique para el color de Background de esa pagina
        String Fondo = getParameter( "Fondo" );
        if( Fondo == null )
             fondo = Color.lightGray;
        else
            {
            try {
                fondo = new Color( Integer.parseInt( Fondo,16 ) );
            } catch( NumberFormatException e ) {
                fondo = Color.lightGray;
                }
            }
        setBackground( fondo );

        // Nos creamos un timer, para actualizar el reloj cada segundo
        Timer timer = new Timer( this );        

        // Creamos un objeto Etiqueta, para que nuestro reloj aparezca
        // con un texto decente y bonito
        horaActual = new Etiqueta();
        horaActual.setFont( "Helvetica",Font.PLAIN,18 );
        horaActual.setColor( new Color( 128,0,0 ) );
        horaActual.setAlto( 25 );
        horaActual.setAncho( 100 );
        horaActual.setSombra( Etiqueta.TextoHundido );
        horaActual.setBorde( true );
        add( horaActual );

        // Arrancamos el timer para que el reloj empiece a marchar
        timer.start();
        }  

 
    // En cada aviso de que nuestro Timer ha llegado al intervalo de
    // tiempo que nosotros hemos fijado, cogemos la hora del sistema
    // y la presentamos
    public void timerIntervalo( Timer t ) {
        Date actual = new Date();
        int horas = actual.getHours();
        int minutos = actual.getMinutes();
        int segundos = actual.getSeconds();
        int hora;
        String tiempo = "";

        // Los "ifs" que siguen son para formatear la hora
        // correctamente y que siempre ocupe lo mismo en la
        // Etiqueta, para que no salten las horas de posicion al
        // presentarse en pantalla
        if( horas > 12 )
            hora = horas - 12;
        else
            hora = horas;
        if( hora < 10 )
            tiempo += "0";
        tiempo += hora;
        tiempo += ":";

        if( minutos < 10 )
            tiempo += "0";
        tiempo += minutos + ":";

        if( segundos < 10 )
            tiempo += "0";
        tiempo += segundos;

        if( horas > 12 )
            tiempo += " pm";
        else
            tiempo += " am";

        horaActual.setText( tiempo );
        }

    // Sobrecargamos los metodos que no nos interesan de la interface
    // Temporizador, porque solamente vamos a utilizar la que genera
    // un evento cada cierto intervalo de tiempo, las demas no tienen
    // interes en este ejemplo
    public void timerArrancado( Timer t ) { }

    public void timerParado( Timer t ) { }
     
    public void timerMuerto( Timer t ) { }

    public void paint( Graphics g ) {
        g.setColor( fondo );
        g.fillRect( 0,0,size().width,size().height );
        }
    }

public interface Temporizador {
    public void timerArrancado( Timer timer );  
    public void timerParado( Timer timer );  
    public void timerMuerto( Timer timer );
    public void timerIntervalo( Timer timer );
    }

import java.lang.*;
import java.util.*;

public class Timer implements Runnable {
    private Date inicio,parada;
    private Thread thread = null;
    private int duracion = 0;
    private int duracionAnt = 0;
    private int intervalo = 1000;
    private boolean repeticion = false;
    private boolean enEjecucion = false;
    private Temporizador handler = null;
   
    // Contructor basico, usado por defecto
    Timer() { }
   

    // Los siguientes constructores son de conveniencia, porque todas
    // las caracteristicas del timer se pueden ver y modificar a
    // traves de los metodos get y set
    // Constructor de conveniencia que acepta un tiempo de duracion
    Timer( int tiempo ) {
        setDuracion( tiempo );
        }
   

    // Constructor de conveniencia que acepta un Temporizador
    Timer( Temporizador Handler ) {
        setHandler( Handler );
        }
   

    // Constructor de conveniencia que acepta un temporizador y una
    // duracion
    Timer( int tiempo,Temporizador Handler ) {
        setDuracion( tiempo );
        setHandler( Handler );
        }
     

    // Fija el numero se segundos que correra el timer
    public void setDuracion( int tiempo ) {
        duracion = tiempo;
        }
   

    // Fija el objeto que ha de ser notificado de los eventos que
    // sucedan al timer
    public void setHandler( Temporizador Handler ) {
        handler = Handler;
        }
   

    // Fija el numero de milisegundos entre pulsos del timer
    public void setIntervalo( int Intervalo ) {
        intervalo = Intervalo;
        }
   

    // Funciones "get" para recoger los datos de las caracteristicas
    // que se han fijado antes
    public int getDuration() {
        return( duracion );
        }
 
    public Temporizador getHandler() {
        return( handler );
        }
 
    public int getIntervalo() {
        return( intervalo );
        }  
   

    // Devuelve el numero de segundos que han transcurrido desde que
    // se arranco el timer
    public int getElapsed() {
         return( calculaLapso( new Date() ) );
        }  
 

    // Este metodo permite resetear el timer antes de relanzarlo. Se
    // podria usar el metodo setDuracion, pero este es mas corto
    // y elegante
    public void resetDuracion() {
        duracion = duracionAnt;
        }  
       

    // Aqui creamos un nuevo thread para correr el Timer. Lo incializamos
    // con "this" de forma que el metodo run() se llame inmediatamente
    // como comience la ejecucion del thread
    public void start() {
        thread = new Thread( this );
        thread.start();
        }
 

    // Aqui almacenamos el momento en que se llama a este metodo.
    // Tambien comprobamos si hay algun Temporizador asociado al Timer
    // que estamos parando, en cuyo caso, notificamos a los observadores
    // de este Timer que lo hemos detenido (para eso esta la interface
    // Temporizador, que debera estar implementada en las clases que
    // miren a este Timer)
    public void stop() {
        enEjecucion = false;
        parada = new Date();
        if ( handler != null )
            handler.timerParado( this );
        }
   

    public void run() {
        enEjecucion = true;
        duracionAnt = duracion;
 
        // Arrancamos el Timer y lo notificamos a las clases que esten
        // poendientes
        inicio = new Date();
        if( handler != null )
            handler.timerArrancado( this );
 
        while( enEjecucion )
            {
            // Esperamos el tiempo que nos hayan dicho en la configuracion
            // del intervalo
            try {
                esperar( intervalo );
            } catch( InterruptedException e ) {
                return;
                }
             
            // Cuando se cumple el intervalo, avisamos a las clases que
            // esten pendientes. Si esas clases no quieren hacer nada
            // con este evento periodico, es suficiente con que no lo
            // sobrecarguen, que se quede vacio
            if( handler != null )
                handler.timerIntervalo( this );
             
            // Si no indicamos una duracion para el Timer, estara
            // corriendo indefinidamente
            if( duracion > 0 )
                {
                // Comprobamos si el Timer esta muerto ya, para no
                // tener que matarlo
                if( estaMuerto() )
                    {
                    // Si esta muerto, lo propagamos
                    if( handler != null )
                        handler.timerMuerto( this );              
               
                    // Aqui comprobamos si se quiere una repeticion
                    // automatica, en cuyo caso, volvemos a arrancar
                    // el Timer
                    if( repeticion )
                        {
                        enEjecucion = true;
                        inicio = new Date();
                        if( handler != null )
                            handler.timerArrancado( this );  
                        }
                    else
                        {
                        enEjecucion = false;
                        }
                    }
                }
            }
        }    
   
    // Metodos que nos informan del estado del Timer
    public boolean estaCorriendo() {
        return( enEjecucion );
        }
   
    public boolean estaParado() {
        return( !enEjecucion );
        }
   

    public boolean estaMuerto() {
        int segundos = 0;
 
        // Calculamos el intervalo de tiempo que ha transcurrido desde
        // que se ha arrancado el Timer
        segundos = calculaLapso( new Date() );
 
        if( segundos >= duracion )
            return( true );
        else
            return( false );
        }
         

    private int calculaLapso( Date actual ) {
        Date dfinal;
        int  segundos = 0;
 
        if( enEjecucion )
            dfinal = actual;
        else
            dfinal = parada;
 
        // Si se quiere mas precision, en vez de Date(), se puede
        // utilizar System.currentTimeMillis(), que proporciona
        // muchisima mas resolucion
        segundos += ( dfinal.getHours() - inicio.getHours() ) * 3600;
        segundos += ( dfinal.getMinutes() - inicio.getMinutes() ) * 60;
        segundos += ( dfinal.getSeconds() - inicio.getSeconds() );
        return( segundos );
        }
   

    // Aqui implementamos la espera. El lapso en milisegundos se lo
    // pasamos al metodo wait() del thread
    // Este metodo es sincronizado porque sino salta una excepcion
    // interna en el interprete de Java. No esta muy bien documentado
    // el porque, pero parece ser que no se puede llamar al metodo
    // wait() de un thread desde otro que no sea sincronizado
    private synchronized void esperar( int lapso )
        throws InterruptedException {
        this.wait( lapso );
        }  
    }