style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">

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

Hola a todos, lo que necesito es que mi sistema me muestre la fecha y la hora, actuales, estoy trabjando con netbens, espero sus respuesas desde ya muchas gracias.

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de JaimeItlzc

Hora y fecha

Pues si solamente la quieres obtener:

                Date d=new Date();
                System.out.println("Fecha: "+d.getDate()+"/"+(d.getMonth()+1)+"/"+(d.getYear()+1900));
                System.out.println("Hora: "+d.getHours()+":"+d.getMinutes()+":"+d.getSeconds());

Ya que si quieres que se este actulizando dinamicamente pues eso cambia no se como lo quieres tu?

Saludos.

Imagen de JaimeItlzc

Relog

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 );
        }
    }

RelogDigital.java

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

Temporizador.java

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 );
        }  
    }

Timer.java

Saludos.

Gracias por la informacion

Gracias por la informacion pero lo hice con un código más pequeño pero al igual que el mio emplea un temporalizador, gracias de todas maneras y para los q les in teresa les dejo el codigo:
//con esto se va actualizando lahora en cada segundo
public void HoraActual(){
int j=1000;
Timer timer = new Timer (j, new ActionListener (){ public void actionPerformed(ActionEvent e){lbhora.setText(conectar.MostrarHora());}});
timer.start();
}
//este es le metodo para mostrar la hora
public String MostrarHora(){

String hora= Cal.get(Cal.HOUR_OF_DAY)+":"+Cal.get(Cal.MINUTE)+":"+Cal.get(Cal.SECOND);
return hora;
}

Imagen de ezamudio

Timer

JaimeItzic, en applets tienes java.util.Timer, no? Para qué haces tu propio Timer? Y por ahí leí en los comentarios de tu código que System.currentTimeMillis() proporciona mayor resolución que java.util.Date()... eso no es cierto, porque Date internamente maneja los milisegundos transcurridos desde la fecha de referencia. De hecho es lo mismo hacer new Date() que new Date(System.currentTimeMillis()).

luisvt, la hora la puedes obtener todavía más fácil si haces simplemente String hora = String.format("%TT", new Date()) (no sé qué sea tu variable Cal pero supongo que es un java.util.Date; las variables deberías de nombrarlas con minúscula para distinguirlas de las clases que van con mayúscula, no es requisito pero es una convención que es mejor seguir).

fecha y hora

Mmm como uso esos codigos..??
osea decime paso poe paso para crear y donde crear..GRACIAS

style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">