LA NECESIDAD DE MEDIR EL TIEMPO
La historia dice que
el ser humano desde que tuvo conciencia de la existencia del universo, vio la
necesidad de medir el tiempo y tomando como base el día y la noche ideo los
calendarios como los sistemas para medir el tiempo. Aunque la base física de
medida del tiempo es el día y la noche; el principio para la elaboración de los
calendarios se basa en las influencias que los movimientos de la tierra tienen
en los estados del sol y de la luna.
De acuerdo a los
principios de los movimientos de la tierra el ser humano (hombres y mujeres) en
diferentes culturas idearon sus propios calendarios. Así por ejemplo, en la
cultura Babilónica existió el calendario babilónico y se componía de doce meses
de treinta días. Este calendario tuvo el inconveniente que con el trascurrir
del tiempo las fases de la luna no coincidían con las fechas que señalaban el
calendario, el desfase entre los estados de la luna y el calendario babilónico era
de 5 días y ¼ de día. La cultura griega
ideo un calendario de doce meses de 29 y 30 días en forma alterna y agregaban
un nuevo mes cada tercero, sexto y octavo mes. Esta propuesta de calendario no
resulto práctica. Hacia el siglo VII
antes de Cristo los romanos idearon un calendario de diez meses que en total
sumaban 304 días y el año comenzaba en marzo. Este calendario propuesto por los
romanos con el tiempo se desfasaba en los ciclos de las estaciones. En este
mismo siglo VII durante el reinado del rey Numa Pompilio se le añadieron dos
nuevos meses, Enero y Febrero. Sin embargo la introducción de estos dos nuevos
meses no se corrigió el desfase. Para corregir los errores del calendario
romano Julio Cesar estableció un nuevo calendario que entró en vigencia el
primero de enero del año 45 antes de Cristo. El calendario juliano se basaba en
el año egipcio que tenía 365 días y un cuarto de día. Y para este cuarto de día
cada cuatro años se le agregaba un día más al mes de febrero, aquí se origina
los años bisiestos. Posteriormente por una errada interpretación se decidió que
los años bisiestos fueran cada tres años lo cual condujo a un desfase de
nuestra era, después de Cristo. En el año de de 1477 había un desase con los
ciclos de las estaciones y esto afectaba
a la celebración de la Pascua y Resurrección y otras fiestas cuyas fechas dependían de esta fiesta. Para corregir todos estos inconvenientes que
originaban este desfase el papa Gregorio XIII nombró una comisión para revisar
el calendario juliano y de acuerdo al informe de esta comisión en marzo de 1582,
el papa Gregorio XIII abolió el calendario juliano e introdujo un nuevo
calendario, llamado posteriormente el calendario gregoriano actualmente seguido
por la gran mayoría de cultura del mundo.
EL CALENDARIO GREGORIANO
El calendario
gregoriano se estableció el 4 de octubre de 1582 del calendario juliano fue
adoptado la mayoría de los países católicos. El calendario gregoriano divide el
año en doce meses y comienza el primero de enero. El número de días que tiene
cada mes es de 30 días para los meses de abril, junio, septiembre y noviembre;
y 31 días para los meses de enero, marzo, mayo, julio, agosto, octubre y diciembre;
y febrero 28 días con excepción de los años bisiestos que tiene 29 días.
Lista ordenada de
meses del año será:
<Enero, Febrero, Marzo, Abril,
Mayo, Junio, Julio, Agosto, Septiembre, Octubre, Noviembre, Diciembre>
Si enumeramos los
meses como:
<Enero = 1, Febrero = 2, Marzo
= 2, Abril = 4, Mayo = 5, Junio = 6, Julio = 7, Agosto = 8, Septiembre = 9,
Octubre = 10, Noviembre = 11, Diciembre = 12>
Para la configuración
del calendario de un mes los días se agrupan en semanas de siete días. Una
semana se representa por la lista ordenada:
<Domingo, Lunes, Martes, Miércoles, Jueves, Viernes, Sábado>
De acuerdo a esto podríamos
decir que el calendario de un mes se construiría sobre una matriz de seis filas
por siete columnas. A continuación se muestra un ejemplo del calendario de un
mes de 31 días y el día primero cae en sábado.
Figura 1. Matriz
configuración de un calendario mensual
|
 |
Para elaborar un
calendario de un mes cualquiera de un determinado año se debe tener en cuenta
lo siguiente:
1. El número de días que tiene el mes
2. El día de la semana del día primero del mes
Para el número de días
del mes se analiza si el mes tiene 30, 31, 28 o 29 días. Un mes tiene 30 días
se pertenece al subconjunto <Abril, Junio, Septiembre, Noviembre>. Un mes
tiene 31 días si pertenece al subconjunto <Enero, Marzo, Mayo, Julio, Agosto, Octubre, Diciembre> y
28 0 29 si es febrero. El mes de febrero tiene 29 días si el año es bisiesto o
28 si no es bisiesto. Desde el punto de vista matemático un año es bisiesto si
es divisible por 4 excepto los divisibles por 100 al menos que se divisible por
400.
ALGORITMO PARA HALLAR LOS AÑOS BISIESTOS
Un año es bisiesto si
es verdadera la siguiente expresión lógica:
esBisiesto = ((año mod 4) = 0) ν ((año mod 100) ≠ 0 ˄ (año mod 400) = 0)
El algoritmo para
programar el método que realiza la tarea de averiguar si un determinado años es
bisiesto o no, es como sigue:
esPrimo( año:int) : boleano
Evaluar expresión→ ((año mod 4) = 0) ν ((año mod 100) ≠ 0 ˄ (año mod 400) = 0)
Si
valor expresión es verdadero entonces
el año es bisiesto
De lo contrario el año no
es bisiesto
Fin
del algoritmo
|
Algoritmo para hallar
el número de días que tiene un determinado mes
El método en java que
implementa el algoritmo será como el que se presenta a continuación:
public
static boolean esBisiesto(int año){
return
(año%4==0)||((año%100!=0)&&(año%400==0));
}
|
Este algoritmo es válido
para un año mayor o igual 1583. Para mayores de este corresponde a otros
calendarios, diferentes al calendario gregoriano. Entonces una instrucción válida
en java para saber si es bisiesto o no, puede ser como la siguiente:
if(esBisiesto(año))
System.out.println(“Es bisiesto”) else System.out.println(“No es bisiesto”);
|
ALGORITMO PARA HALLAR EL NÚMERO DE DÍAS QUE TIENE UN DETERMINADO MES
Para calcular el
número de días que tiene un determinado mes se procede de la siguiente manera:
- Se analiza si el mes dado es febrero y en el caso que lo fuera se averigua si el año es bisiesto y si lo es entonces el mes tiene 29 y si el año no es bisiesto entonces el mes tiene 28 dias.
- En el caso que no sea febrero se analiza si el mes dado está en el subconjunto de los meses que tienen 30 días y en el caso que se encuentre entonces se dice que el mes tiene 30 días.
- Si el mes no se encuentra en los subconjuntos analizados en los pasos 1 y 2 entonces el mes tiene 31 días.
obtenerDiasMes(año: int, mes: int): int
asumamos que diasMes = 31
Analizamos el valor de (mes)
case: <2> entonces:
si año es bisiesto diasMes ! 29 de otra manera diasMes ! 28
case: <4, 6, 9, 11> entonces:
diasMes ! 30
retorne el valor que tiene diasMes
Fin del algoritmo
|
public static int getDiasMes(int
año,int mes){
int diasMes=31;
switch(mes){
case 2:
if(esBisiesto(año))diasMes=29;
else diasMes=28;
break;
case 4:case 6:case 9:case 11:
diasMes=30;
}
return diasMes;
}
|
Son muchas las razones
para querer saber el día de la semana que cayó o caerá una determinada fecha
del calendario gregoriano. Ejemplos: el deseo de una persona saber en qué día
de la semana nació, el fabricante de almanaques quiere saber los días de las
semanas en que el primero de cada mes, y muchas más razones que no son
importantes de discutir por ahora.
Para el caso de la
implementación del software para un calendario interactivo es necesario saber
la manera de encontrar el día de la semana en que cae el primero de cada para
un año cualquiera válido en el calendario gregoriano. Si encontramos un
algoritmo que nos permita hallar el día de la semana de cualquier fecha nos
será fácil hacer el software que permita visualizar e interactuar con
calendarios como el que se muestra en la siguiente figura.
Figura 2. Ejemplo de un
calendario interactivo
|
 |
El calendario de la
figura anterior corresponde a la fecha del 11 de agosto de 2013 y el usuario
puede interactuar con este calendario seleccionando cualquier día del mes
buscar un determinado mes pulsando las flechas de atrasar o avanzar meses o
digitar un año determinado para el calendario en dicho año.
Existen muchos tipos
de algoritmos para hallar el día se la semana para una determinada fecha dado
el año, el mes y el día del mes. Pero para nuestro coso tomamos el algoritmo
ideado por el señor Julius Christian Johannes Zeller. Sin entrar a profundizar
la manera como el señor Zeller encontró el algoritmo su definición es como se
muestra a continuación:
calcularDiaSemana(año: int, mes: int, dia: int): int
d: int <domingo = 0, lunes = 1,martes =
2, miércoles = 3, jueves = 4, viernes = 5, sábado = 6>
año: int <año≥1583>
mes: int <enero =1, febrero=2, marzo=3,
abril=4, mayo=5, junio=6, julio=7, agosto=8, septiembre=9,
octubre=10, noviembre=11, diciembre=12>
a, y, m: int
1. a = (14 – mes)/12
2. y = año – a
3. m = mes – (12*a) – 2
4. d = (dia + y + (y/4) – (y/100) + (y/400)
+ (31*m)/12) mod 7
5. tomar el valor de d como el día de la semana en el que cae la fecha dada año/mes/dia
Fin del algoritmo
|
La implementación del
algoritmo como un método de java es como el que se muestra a continuación:
public static int
calcularDiaSemana(int año,int mes,int dia){
int a,y,m,d;
a=(14-mes)/12;
y=año-a;
m=mes+(12*a)-2;
d=(dia+y+(y/4)-(y/100)+(y/400)+(31*m)/12)%7;
return d;
}
|
Ejercicio resuelto. Hacer los cálculos para averiguar qué día de
la semana cayó el 20 de julio de 1810. Fecha del grito de la independencia de
Colombia. La historia dice que era un viernes día de mercado cuando…
Cálculos: año = 1810; mes = 7; día = 20; a = (14 – 7)/12 = 0 [división de
enteros], entonces a = 0; y = 1810 – 0 = 1810, entonces y = 1810; m = 7 +(12*0)
– 2 = 5; entonces m =5; d = (20+1810+(1810/4)-(1810/100)+(1810/400)+(31*5)/12)
mod 7= (20+1810+452-18+4+12) mod 7 = 5, entonces d = 5 y el corresponde al
viernes que coincide con lo de dice la historia.
Ejercicio para resolver. Llenar los cuadros de la matriz de la figura que
se muestra a continuación para que corresponda al calendario del mes de febrero del año 3500.
Figura 3. Matriz para llenar calendario
CÓDIGO JAVA PARA HALLAR LA FECHA ACTUAL
La plataforma de
desarrollo de programas en java proporciona varias clases y métodos para obtener
la fecha actual, la fecha del sistema computador. Una de estas clases es la
clase Calendar y que se encuentra en
el paquete java.util. Para que usted inicie el estudio de la clase Calendar a continuación se presenta un
pequeño programa java que obtiene y muestra en la consola la fecha actual del
sistema.
import java.util.*;
public class CalculoFechaActual {
public static void main(String[] args) {
Calendar
fecha=Calendar.getInstance();
int
añoActual=fecha.get(Calendar.YEAR);
int
mesActual=fecha.get(Calendar.MONTH)+1;
int
diaActual=fecha.get(Calendar.DAY_OF_MONTH);
System.out.print("La fecha
actual del sistema es: ");
System.out.println(añoActual+"/"+mesActual+"/"+diaActual);
}
}
|
Analice el código
anterior y saque sus propias conclusiones y aplíquelas en el desarrollo de sus
aplicaciones. Es importante que estudie los diferentes métodos que proporciona
esta clase, la clase Calendar.
Caso de estudio: Diseño y
programación de un calendario
Desarrollar en java un
calendario que le permita al usuario seleccionar cualquier fecha desde el año
1583 (año en que el comenzó a regir el calendario gregoriano) hasta el año en
que propongan un nuevo sistema de calendario. La vista del calendario
interactivo para esta aplicación debe ser como el que se muestra en la
siguiente figura.
Figura 4. Vista calendario para la
aplicación
|
La vista del
calendario de la figura anterior muestra la fecha: 13 de agosto de 2013
(1/8/2013). El usuario puede seleccionar cualquier año digitando en el campo de
texto de la barra inferior y para confirmar el año se pulsa la tecla ENTER del
teclado del computador. Al pulsar ENTER se visualizará el calendario del mes de
enero del año editado. Para seleccionar el mes el usuario pulsará las flechas
de avanzar o atrasar y luego seleccionar
el correspondiente día del mes. Al pulsar el botón de cerrar el calendario se
ocultará y la fecha seleccionada quedará
disponible para la aplicación. Siempre que introduce un nuevo año desde
el campo de texto de la barra inferior se visualizara el mes de enero y el día
primero seleccionado. El paso de un mes a otro el calendario del nuevo mes
muestra el día primero seleccionado, independiente del día que estaba
seleccionado del anterior mes. Algunas consideraciones o especificaciones: a) si
el mes visualizado en el calendario es enero de una año cualquier y se pulsa el botón de la flecha de
retroceder el calendario debe mostrar el mes de diciembre del año anterior y b)
si el mes visualizado en el calendario es el mes de diciembre de un año
cualquiera y se pulsa el botón de la flecha de adelantar entonces el calendario
mostrará el mes de enero del año siguiente. Para el uso de este
calendario se debe implementar una aplicación cuya ventana de uso es como la
que se muestra en la siguiente figura.
Figura 5. Vista ventana usuaria
calendario
|
La interacción del
usuario con la aplicación es muy simple, al pulsar el botón “Seleccionar Fecha”
se visualizará el calendario como el que se muestra en la figura 4 y una vez
seleccionada la fecha y cerrado el calendario esta fecha seleccionada se
visualizará en la ventana de la aplicación.
Especificación de requerimientos
Figura 6. Diagrama de casos de uso
|
Diseño estructural
Figura 7. Diseño arquitectónico
estático
|
La vista del diagrama
de la figura anterior nos muestra que este sistema consta de cuatro clases
definidas en el paquete aplicación. Según el diseño arquitectónico estático la
clase Aplicación tiene dependencia de
la clase VentanaPrincipal, y esta
última tiene dependencia de las clases Fecha
y Calendario y esta última tiene a su
vez dependencia de la clase Fecha.
Las clases VentanaPrincipal y Calendario tienen relaciones de herencia
con las clases JFrame y JDialog respectivamente. Las clases JFrame y JDialog son proporcionadas por el paquete javax.swing proporcionado por
las plataformas de desarrollo java.
Recomendación
1. Siempre que usted necesite desarrollar una
aplicación software con lenguajes orientados a objetos, dedique un tiempo a
dibujar el diseño arquitectónico estático antes de tomar un computador para
empezar a escribir el código. Le quiero decir, que si usted tiene previamente
el diseño arquitectónico le será muy fácil el montaje de las clases que
componen el proyecto.
|
Diseño Modelo Dinámico
Figura 8. Diseño arquitectónico dinámico
|
Tutorial: Montaje de un proyecto java
Este tutorial le
suministra el conocimiento requerido para montar un proyecto siguiendo un
diseño arquitectónico como el que se muestra en la figura anterior.
- Abrir el entorno de desarrollo (para nuestro caso será NetBeans 7.3). Con esto nuestro computador queda listo para iniciar el trabajo de desarrollo del proyecto.
- Crear un nuevo proyecto desde el menú Archivo o dar el comando abreviado <Ctrl> <Mayus><N> para visualizar el cuadro de diálogo para seleccionar la categoría y el tipo de proyecto. Se selecciona la categoría Java y el tipo de proyecto Java Aplicación y posteriormente pulse el botón siguiente (Next) para proceder a editar el nombre del proyecto.
- En el cuadro de diálogo de Nuevo proyecto se edita el nombre del proyecto y para nuestro caso y según el diseño arquitectónico el nombre es aplicación(nombre del paquete que contendrá nuestras clases). La plataforma en forma automática pone el nombre la clase Aplicación. Observe que es el mismo nombre del paquete pero la primera letra en mayúscula. La clase Aplicación será la clase ejecutable y será la que contiene el método estático main().
- Las cuatro clases serán ubicadas en diferentes archivos. Observe que las cuatro clases están en el mismo paquete llamado aplicación. Se implementan las dos relaciones de herencia de las clases VentanaPrincipal y Calendario.
- Programación de clases y pruebas.
- Fin del tutorial
Programación de las clases
Programación de la clase Fecha
package aplicacion;
import
java.util.*;
public class Fecha {
public static Calendar
calendario=Calendar.getInstance();
// *********
private static int
añoSel,mesSel,diaSel,diaSemanaSel;
public static boolean
fechaDisponible=false;
// *********
public static String
strMeses[]={"Enero","Febrero","Marzo","Abril","Mayo",
"Junio","Julio","Agosto","Septiembre","Octubre","Noviembre","Diciembre"};
public
static String
strDiasSemana[]={"Domingo","Lunes","Martes","Miercoles",
"Jueves","Viernes","Sábado"};
public static String toStringFecha(){
return
calendario.get(Calendar.DAY_OF_MONTH)+"/"+(calendario.get(Calendar.MONTH)+1)+"/"+
calendario.get(Calendar.YEAR);
}
public void incrementarMes(){
calendario.set(Calendar.MONTH,calendario.get(Calendar.MONTH)+1);
calendario.set(Calendar.DAY_OF_MONTH,1);
}
public void decrementarMes(){
calendario.set(Calendar.MONTH,calendario.get(Calendar.MONTH)-1);
calendario.set(Calendar.DAY_OF_MONTH,1);
}
public void establecerDia(int dia){
calendario.set(Calendar.DAY_OF_MONTH,dia);
}
public void establecerMes(int mes){
calendario.set(Calendar.MONTH,mes-1);
calendario.set(Calendar.DAY_OF_MONTH,1);
}
public void establecerAño(int año){
calendario.set(Calendar.YEAR,año);
calendario.set(Calendar.DAY_OF_MONTH,1);
}
public int obtenerDiaSemana(){
return
calendario.get(Calendar.DAY_OF_WEEK)-1;
}
public int obtenerDia(){
return
calendario.get(Calendar.DAY_OF_MONTH);
}
public int obtenerMes(){
return
calendario.get(Calendar.MONTH)+1;
}
public int obtenerAño(){
return calendario.get(Calendar.YEAR);
}
public String toStrintMesAño(){
String
mensaje=strMeses[obtenerMes()-1]+"
"+Integer.toString(obtenerAño());
return mensaje;
}
public int calcularDiaSemanaPrimero(){
int
año=calendario.get(Calendar.YEAR);
int mes=calendario.get(Calendar.MONTH)+1;
int dia=1;
int a,y,m,d;
a=(14-mes)/12;
y=año-a;
m=mes+(12*a)-2;
d=(dia+y+(y/4)-(y/100)+(y/400)+(31*m)/12)%7;
return d;
}
public boolean esBisiesto(){
int
año=calendario.get(Calendar.YEAR);
return
(año%4==0)||((año%100!=0)&&(año%400==0));
}
public int getDiasMes(){
int
año=calendario.get(Calendar.YEAR);
int mes=calendario.get(Calendar.MONTH)+1;
int diasMes=31;
switch(mes){
case 2:
if(esBisiesto())diasMes=29;
else diasMes=28;
break;
case 4:case 6:case 9:case 11:
diasMes=30;
}
return diasMes;
}
// ************
public static int _getAño(){
return añoSel;
}
public static int _getMes(){
return mesSel;
}
public static int _getDia(){
return diaSel;
}
public static int _getDiaSemana(){
return diaSemanaSel;
}
public static void _setAño(int año){
añoSel=año;
}
public static void _setMes(int mes){
mesSel=mes;
}
public static void _setDia(int dia){
diaSel=dia;
}
public static void _setDiaSemanaSel(int
dia){
diaSemanaSel=dia;
}
}
|
Programación de la clase Calendario
package aplicacion;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Calendario
extends JDialog implements ActionListener,KeyListener{
final int ANCHO=252,ALTO=180;
final Cursor mano=new
Cursor(Cursor.HAND_CURSOR);
JPanel
paneles[]=new JPanel[4];
JButton
btnCerrar,btnAdelantar,btnAtrasar;
JLabel etiqDiasSemana[]=new JLabel[7];
JButton btnDiasMes[]=new JButton[42];
JLabel etiqAño,etiqMesAño;
JTextField txtAño;
Font fuente;
String
flechaAtras=String.valueOf('\u25C4');
String
flechaAdelante=String.valueOf('\u25BA');
String
strDiasSemana[]={"Dom","Lun","Mar","Mie","Jue","Vie","Sab"};
Color
fondoTitulo,fondoDiaSeleccionado,fondoDiasMes,fondoSemana;
Fecha fecha;
public static int AÑO,MES,DIA;
Calendario(){
fecha=new Fecha();
setSize(ANCHO,ALTO);
setLayout(null);
setModal(true);
fondoTitulo=new Color(20,255,20);
fondoDiaSeleccionado=new Color(100,255,100);
fondoSemana=new Color(200,255,200);
fondoDiasMes=new Color(255,255,255);
this.setLocationRelativeTo(null);
setUndecorated(true);
fuente=new
Font("serif",Font.PLAIN+Font.BOLD,12);
inicializarComponentes();
establecerCalendario();
}
private void inicializarComponentes(){
int a=ALTO/9, b=ANCHO/7;
fecha=new Fecha();
for(int i=0;i<paneles.length;i++){
paneles[i]=new JPanel();
add(paneles[i]);
switch(i){
case 0:
paneles[i].setLayout(null);
paneles[i].setBounds(0,0,ANCHO,a);
paneles[i].setBackground(fondoTitulo);
btnCerrar=new
JButton("X");
btnCerrar.setCursor(mano);
btnCerrar.setFont(fuente);
btnCerrar.setBounds(ANCHO-a-4,1,a,a-2);
btnCerrar.setBorder(BorderFactory.createEtchedBorder());
btnCerrar.setBackground(new Color(255,0,0));
btnCerrar.setForeground(new Color(255,255,255));
paneles[i].add(btnCerrar);
btnCerrar.addActionListener(this);
btnAtrasar=new
JButton(flechaAtras);
btnAtrasar.setCursor(mano);
btnAtrasar.setBounds(a-8,1,a,18);
btnAtrasar.setBackground(fondoTitulo);
btnAtrasar.setBorder(BorderFactory.createEmptyBorder());
btnAtrasar.setHorizontalAlignment(JButton.CENTER);
btnAtrasar.setForeground(new
Color(0,0,255));
paneles[i].add(btnAtrasar);
btnAtrasar.addActionListener(this);
btnAdelantar=new
JButton(flechaAdelante);
btnAdelantar.setCursor(mano);
btnAdelantar.setBounds(ANCHO-2*a-8,1,a,18);
btnAdelantar.setBackground(fondoTitulo);
btnAdelantar.setBorder(BorderFactory.createEmptyBorder());
btnAdelantar.setHorizontalAlignment(JButton.CENTER);
btnAdelantar.setForeground(new Color(0,0,255));
paneles[i].add(btnAdelantar);
btnAdelantar.addActionListener(this);
add(paneles[i]);
etiqMesAño=new JLabel();
etiqMesAño.setFont(fuente);
etiqMesAño.setBounds(2*a+8,1,7*a,18);
etiqMesAño.setHorizontalAlignment(JLabel.CENTER);
paneles[i].add(etiqMesAño);
break;
case 1:
paneles[i].setLayout(new
GridLayout(0,7));
paneles[i].setBounds(0,a,ANCHO,a);
paneles[i].setBackground(fondoSemana);
for(int
j=0;j<etiqDiasSemana.length;j++){
etiqDiasSemana[j]=new
JLabel(strDiasSemana[j]);
etiqDiasSemana[j].setBounds(0,a,a,18);
etiqDiasSemana[j].setFont(fuente);
etiqDiasSemana[j].setHorizontalAlignment(JLabel.CENTER);
etiqDiasSemana[j].setBorder(BorderFactory.createEtchedBorder());
if(j==0)etiqDiasSemana[j].setForeground(new
Color(255,0,0));
else
etiqDiasSemana[j].setForeground(new Color(0,0,255));
paneles[i].add(etiqDiasSemana[j]);
}
add(paneles[i]);
break;
case 2:
paneles[i].setLayout(new
GridLayout(6,7));
paneles[i].setBounds(0,2*a,ANCHO,ALTO-3*a);
for(int
j=0;j<btnDiasMes.length;j++){
btnDiasMes[j]=new
JButton();
btnDiasMes[j].setCursor(mano);
btnDiasMes[j].setBackground(fondoDiasMes);
btnDiasMes[j].setBorder(BorderFactory.createEtchedBorder());
paneles[i].add(btnDiasMes[j]);
btnDiasMes[j].addActionListener(this);
}
break;
case 3:
paneles[i].setLayout(null);
paneles[i].setBounds(0,8*a,ANCHO,a);
paneles[i].setBackground(new Color(0,255,0));
etiqAño=new
JLabel("Digite año: ");
etiqAño.setBounds(2,2,80,18);
etiqAño.setFont(fuente);
etiqAño.setBackground(new Color(0,255,0));
etiqAño.setHorizontalAlignment(JLabel.RIGHT);
paneles[i].add(etiqAño);
add(paneles[i]);
txtAño=new JTextField();
txtAño.setBounds(90,1,60,18);
txtAño.setBackground(fondoDiasMes);
txtAño.setBorder(BorderFactory.createBevelBorder(1));
txtAño.setHorizontalAlignment(JTextField.RIGHT);
paneles[i].add(txtAño);
txtAño.addKeyListener(this);
break;
}
}
}
private void limpiarDiasMes(){
for(int
i=0;i<btnDiasMes.length;i++){
btnDiasMes[i].setText(null);
btnDiasMes[i].setEnabled(false);
btnDiasMes[i].setBackground(fondoDiasMes);
}
}
private void establecerCalendario(){
limpiarDiasMes();
etiqMesAño.setText(fecha.toStrintMesAño());
int d=fecha.calcularDiaSemanaPrimero();
int diasMes=fecha.getDiasMes();
for(int i=0;i<diasMes;i++){
btnDiasMes[d+i].setText(Integer.toString(i+1));
btnDiasMes[d+i].setEnabled(true);
if((d+i)%7==0)btnDiasMes[d+i].setForeground(new Color(255,0,0));
else
btnDiasMes[d+i].setForeground(new Color(0,0,255));
if((i+1)==fecha.obtenerDia())btnDiasMes[d+i].setBackground(fondoDiaSeleccionado);
}
}
// MODELO DINÁMICO
public void actionPerformed(ActionEvent
ev){
if(ev.getSource()==btnCerrar){
dispose();
Fecha._setAño(fecha.obtenerAño());
Fecha._setMes(fecha.obtenerMes());
Fecha._setDia(fecha.obtenerDia());
Fecha._setDiaSemanaSel(fecha.obtenerDiaSemana());
Fecha.fechaDisponible=true;
if(Fecha.fechaDisponible)
txtAño.setText(Integer.toString(Fecha._getAño()));
}else if(ev.getSource()==btnAtrasar){
fecha.decrementarMes();
establecerCalendario();
}else if(ev.getSource()==btnAdelantar){
fecha.incrementarMes();
establecerCalendario();
}else{
int
d=fecha.calcularDiaSemanaPrimero();
int kdias=fecha.getDiasMes();
for(int i=0;i<kdias;i++){
if(btnDiasMes[d+i].getBackground()==fondoDiaSeleccionado)
btnDiasMes[d+i].setBackground(new Color(255,255,255));
if(ev.getSource()==btnDiasMes[d+i]){
fecha.establecerDia(i+1);
btnDiasMes[d+i].setBackground(fondoDiaSeleccionado);
}
}
}
}
public void keyPressed(KeyEvent ev){
if((ev.getKeyChar()=='\n')&&(!txtAño.getText().isEmpty())){
try{
int
año=Integer.parseInt(txtAño.getText());
if(año<1583)throw new
Exception("...");
fecha.establecerAño(año);
fecha.establecerMes(1);
this.etiqMesAño.setText(fecha.toStrintMesAño());
txtAño.setText("");
establecerCalendario();
}catch (Exception e){
txtAño.setText(null);
}
}
}
public void keyReleased(KeyEvent ev){
int año;
try{
año=Integer.parseInt(txtAño.getText());
}catch (Exception e){
txtAño.setText("");
}
}
public void keyTyped(KeyEvent ev){
// Sin uso
}
}
|
Programación de la clase VentanaPrincipal
package aplicacion;
import javax.swing.*;
import java.awt.event.*;
public class
VentanaPrincipal extends JFrame implements ActionListener{
final int ANCHO=450,ALTO=200;
JPanel panel;
JLabel labAño,labMes,labDia,labDiaSemana;
JTextField
txtAño,txtMes,txtDia,txtDiaSem;
JButton btnVerCalendario,btnLimpiar;
public VentanaPrincipal(){
Fecha.fechaDisponible=false;
setSize(ANCHO,ALTO);
setResizable(false);
setLocationRelativeTo(null);
this.setTitle("Aplicación por:
Jorge Herrera Castillo");
this.setLayout(null);
iniciarComponentes();
setVisible(true);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
private void iniciarComponentes(){
panel=new JPanel();
panel.setBounds(10,10,ANCHO-30,110);
panel.setBorder(BorderFactory.createTitledBorder(BorderFactory.createBevelBorder(1),"Fecha
Seleccionada"));
panel.setLayout(null);
labAño=new JLabel("Año:");
labAño.setBounds(20,35,30,20);
labAño.setHorizontalAlignment(JLabel.RIGHT);
panel.add(labAño);
txtAño=new JTextField();
txtAño.setBounds(60,35,50,20);
txtAño.setHorizontalAlignment(JTextField.CENTER);
txtAño.setEditable(false);
txtAño.setBorder(BorderFactory.createBevelBorder(1));
panel.add(txtAño);
labMes=new JLabel("Mes:");
labMes.setBounds(120,35,30,20);
labMes.setHorizontalAlignment(JLabel.RIGHT);
panel.add(labMes);
txtMes=new JTextField();
txtMes.setBounds(160,35,100,20);
txtMes.setHorizontalAlignment(JTextField.CENTER);
txtMes.setEditable(false);
txtMes.setBorder(BorderFactory.createBevelBorder(1));
panel.add(txtMes);
labDia=new JLabel("Dia mes:");
labDia.setBounds(270,35,60,20);
labDia.setHorizontalAlignment(JLabel.RIGHT);
panel.add(labDia);
txtDia=new JTextField();
txtDia.setBounds(340,35,40,20);
txtDia.setHorizontalAlignment(JTextField.CENTER);
txtDia.setEditable(false);
txtDia.setBorder(BorderFactory.createBevelBorder(1));
panel.add(txtDia);
labDiaSemana=new JLabel("Dia Semana:");
labDiaSemana.setBounds(70,75,80,20);
labDiaSemana.setHorizontalAlignment(JLabel.RIGHT);
panel.add(labDiaSemana);
txtDiaSem=new JTextField();
txtDiaSem.setBounds(160,75,100,20);
txtDiaSem.setHorizontalAlignment(JTextField.CENTER);
txtDiaSem.setEditable(false);
txtDiaSem.setBorder(BorderFactory.createBevelBorder(1));
panel.add(txtDiaSem);
add(panel);
btnVerCalendario=new JButton("Seleccionar
Fecha");
btnVerCalendario.setBounds(ANCHO/3-90,ALTO-70,160,30);
btnVerCalendario.setBorder(BorderFactory.createBevelBorder(0));
add(btnVerCalendario);
btnVerCalendario.addActionListener(this);
btnLimpiar=new JButton("Limpiar
Fecha");
btnLimpiar.setBounds(ANCHO/3-90+170,ALTO-70,160,30);
btnLimpiar.setBorder(BorderFactory.createBevelBorder(0));
add(btnLimpiar);
btnLimpiar.addActionListener(this);
}
// Modelo dinámico
public void actionPerformed(ActionEvent
ev){
if(ev.getSource()==btnVerCalendario){
Calendario calendario=new
Calendario();
calendario.setVisible(true);
}else
if(ev.getSource()==btnLimpiar){
txtAño.setText("");
txtMes.setText("");
txtDia.setText("");
txtDiaSem.setText("");
Fecha.fechaDisponible=false;
}
if(Fecha.fechaDisponible){
txtAño.setText(Integer.toString(Fecha._getAño()));
txtMes.setText(Fecha.strMeses[Fecha._getMes()-1]);
txtDia.setText(Integer.toString(Fecha._getDia()));
txtDiaSem.setText(Fecha.strDiasSemana[Fecha._getDiaSemana()]);
}
}
}
|
package
aplicacion;
public
class Aplicacion {
public
static void main(String[] args) {
new VentanaPrincipal();
}
}
|
No hay comentarios:
Publicar un comentario