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.
- Inicie sesión o regístrese para enviar comentarios
Hora y fecha
Pues si solamente la quieres obtener:
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.
Relog
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 void timerArrancado( Timer timer );
public void timerParado( Timer timer );
public void timerMuerto( Timer timer );
public void timerIntervalo( Timer timer );
}
Temporizador.java
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;
}
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()
quenew 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