Obtenga las horas de salida y puesta del sol locales según la latitud y longitud y la fecha actual. Una potente búsqueda en Google me permitió encontrar rápidamente una clase de Java escrita por un extranjero. Los comentarios en el código estaban claramente escritos.
Publique el código directamente aquí:
Copie el código de código de la siguiente manera:
/************************************************ * *******************************
*
*AmanecerAtardecer.java
*
************************************************** * *******************************
*
* Clase de Java: Amanecer y Atardecer
*
*Esta clase Java es parte de una colección de clases desarrolladas para
*lectura y procesamiento de datos oceanográficos y meteorológicos recopilados
*desde 1970 por boyas y estaciones ambientales. Este es un conjunto de datos.
*mantenido por el Centro Nacional de Datos Oceanográficos y es público
*disponibles Estas clases de Java fueron escritas para el Medio Ambiente de EE. UU.
*Laboratorio Nacional de Investigación de Exposiciones de la Agencia de Protección contratada
*No GS-10F-0073K con Neptune and Company de Los Alamos, Nuevo México.
*
*Objetivo:
*
* Esta clase Java realiza cálculos para determinar el tiempo de
*amanecer y atardecer con latitud, duración y fecha.
*
*Entradas:
*
* Latitud, longitud, fecha/hora y zona horaria.
*
*Salidas:
*
* Hora local de salida y puesta del sol calculada por el
* programa.
*Si no sale ni se pone el sol, o si el sol sale todo el día
* o abajo todo el día, se establecen los valores booleanos apropiados.
*Se proporciona un booleano para identificar si la hora proporcionada es durante el día.
*
*Se accede a los valores anteriores mediante los siguientes métodos:
*
*DategetSunrise() devuelve la fecha/hora del amanecer
*DategetSunset() devuelve la fecha/hora de la puesta del sol
*booleanisSunrise() devuelve verdadero si hubo amanecer; en caso contrario, devuelve falso
*booleanisSunset() devuelve verdadero si hubo una puesta de sol; en caso contrario, devuelve falso
*booleanisSunUp() devuelve verdadero si el sol sale todo el día; en caso contrario, devuelve falso
*booleanisSunDown() devuelve verdadero si el sol está puesto todo el día; en caso contrario, es falso
*booleanisDaytime() devuelve verdadero si sale el sol en ese momento
*especificado, de lo contrario falso
*
* Clases requeridas de la biblioteca Java:
*
* java.util.Fecha
*java.text.SimpleDateFormat
*java.text.ParseException;
* java.math.BigDecimal;
*
* Paquete del que esta clase es miembro:
*
*por defecto
*
* Limitaciones conocidas:
*
*Se supone que los datos proporcionados están dentro de rangos válidos
*(es decir, latitud entre -90 y +90, longitud entre 0 y 360,
*una fecha válida y zona horaria entre -14 y +14.
*
*Compatibilidad:
*
*Java 1.1.8
*
* Referencias:
*
*Los algoritmos matemáticos utilizados en este programa están modelados.
*después de los desarrollados por Roger Sinnott en su programa BASIC,
*SUNUP.BAS, publicado en la revista Sky & Telescope:
*Sinnott, Roger W. "Amanecer y atardecer: un desafío"
*Sky & Telescope, agosto de 1994, páginas 84-85
*
*El siguiente es un índice cruzado de las variables utilizadas en SUNUP.BAS.
*Una definición única a partir de la reutilización múltiple de nombres de variables en
*SUNUP.BAS fue aclarado con varias definiciones en este programa.
*
*SUNUP.BASesta clase
*
*AdfA
*A(2)dfAA1, dfAA2
*A0dfA0
*A2dfA2
*A5dfA5
*AZNo utilizado
*CdfCosLat
*C0dfC0
*DiDía
*D(2)dfDD1, dfDD2
*D0dfD0
*D1dfD1
*D2dfD2
*D5dfD5
*D7No utilizado
*DAdfDA
*DDdfDD
*GbGregoriano, dfGG
*HdfZona horaria
*H0dfH0
*H1dfH1
*H2dfH2
*H3dfHourRise, dfHourSet
*H7No utilizado
*JdfJ
*J3dfJ3
*K1dfK1
*LdfLL
*L0dfL0
*L2dfL2
*L5dfLon
*MiMes
*M3dfMinRise, dfMinSet
*N7No utilizado
*PDFP
*SiSign, dfSinLat, dfSS
*TdfT
*T0dfT0
*T3no utilizado
*TTdfTT
*UdfUU
*VdfVV
*V0dfV0
*V1dfV1
*V2dfV2
*WdfWW
*YiAño
*ZdfCenit
*Z0dfZona horaria
*
*
* Autor/Empresa:
*
* JDT: John Tauxe, Neptuno y Compañía
*JMG: Jo Marie Green
*
* Registro de cambios:
*
*fecha ver por descripción del cambio
*_________ _____ _______________________________________________
* 5 de enero de 2001 0.006 JDTExposed de ssapp.java v. 0.005.
*11 de enero de 2001 0,007 JDTModificaciones menores a los comentarios basadas en
*material de Sinnott, 1994.
* 7 de febrero de 01 0.008 JDT Se corrigió la zona horaria al revés. El estándar es ese.
* la zona horaria local se especifica en horas al ESTE de
* Greenwich, por lo que EST sería -5, por ejemplo.
* Por alguna razón, SUNUP.BAS hace esto al revés
* (probablemente una perspectiva americana) y
* SunriseSunset adoptó esa convención.
* Entonces se cambia el signo en las matemáticas.
* 7 de febrero de 01 0,009 JDT Bueno, eso desbarató el cálculo del azimut...
* Se eliminaron los cálculos de azimut.
*14 de febrero de 01 0.010 JDTSe agregó la capacidad de aceptar una hora (HH:mm) en
* dateInput, y decide si esa hora es de día
*o de noche.
*27 de febrero de 2001 0.011 JDT Se agregaron métodos de acceso en lugar de tener públicos.
*variables para obtener resultados.
*28 de febrero de 2001 0.012 JDTLista limpia de clases importadas.
*28 de marzo de 2001 1.10 JDTFersión final que acompaña al entregable 1b.
* 4 de abril de 1.11 JDTMovó la lógica que admite .isDaytime en el método.
* Cálculos movidos fuera del constructor.
* 01 Mayo 01 1.12 JMG Se agregaron líneas de prueba y designación 'GMT'.
* 16 de mayo de 1.13 JDT Se agregaron setLenient( false ) y setTimeZone( tz )
* a dfmtDay, dfmtMonth y dfmtYear en
*hacer cálculos.
* 27 de junio de 2001 1.14 JDT Se eliminó la dependencia de StationConstants (GMT).
*13 de agosto de 2001 1.20 JDTFersión final que acompaña al entregable 1c.
* 6 de septiembre de 2001 1.21 JDTTRevisión exhaustiva de códigos y comentarios.
*21 de septiembre de 2001 1.30 JDTFersión final que acompaña al entregable 2.
*17 de diciembre de 2001 1.40 Versión JDT que acompaña al entregable final.
*
*------------------------------------------------- -------------------------*/
//Importar clases y paquetes requeridos
importar java.util.Fecha;
importar java.text.SimpleDateFormat;
importar java.text.ParseException;
importar java.math.BigDecimal;
importar java.util.TimeZone;
/************************************************ * *******************************
*clase: Clase Amanecer Atardecer
************************************************** * *******************************
*
* Esta clase Java realiza cálculos para determinar el tiempo de
*amanecer y atardecer con latitud, duración y fecha.
*
*Se supone que los datos proporcionados están dentro de rangos válidos
*(es decir, latitud entre -90 y +90, longitud entre 0 y 360,
*una fecha válida y zona horaria entre -14 y +14.
*
*------------------------------------------------- -------------------------*/
clase públicaAmanecerAtardecer
{
// Declarar e inicializar variables
privado doubledfLat;// latitud del usuario
private doubledfLon;// latitud del usuario
fecha/hora privadaInput; // fecha/hora del usuario
private doubledfTimeZone;// zona horaria del usuario
privado DatedateSunrise;// fecha y hora del amanecer
privado DatedateSunset;//fecha y hora de la puesta del sol
private booleanbSunriseToday = false;// marcar el amanecer en esta fecha
private booleanbSunsetToday = false;// marcar el atardecer en esta fecha
private booleanbSunUpAllDay = false;// marcar para que salga el sol todo el día
private booleanbSunDownAllDay = false;// marcar la puesta de sol todo el día
private booleanbDaytime = false; // bandera para el día, dado
// hora y min en dateInput
private booleanbSunrise = false; // amanecer durante la hora marcada
private booleanbSunset = false; // puesta de sol durante la hora marcada
booleanbGregorian privado = false;// bandera para el calendario gregoriano
inti privadoJulian;//día juliano
privateintiYear;// año de la fecha de interés
privateintiMonth;// mes de la fecha de interés
privateintiDay;// día de la fecha de interés
privateintiCount;// un contador simple
privateintiSign;// SUNUP.BAS: S
privado doubledfHourRise, dfHourSet;// hora del evento: SUNUP.BAS H3
privado doubledfMinRise, dfMinSet;// minuto del evento: SUNUP.BAS M3
privatedoubledfSinLat, dfCosLat;// pecado y cos de latitud
privatedoubledfZenith;// SUNUP.BAS Z: Zenith
privateSimpleDateFormat dfmtDate;// formato solo para la fecha
privateSimpleDateFormat dfmtDateTime;// formateo de fecha y hora
privateSimpleDateFormat dfmtYear;// formato para el año
privateSimpleDateFormat dfmtMonth;// formateo del mes
privateSimpleDateFormat dfmtDay;// formateo para el día
// Muchas variables en SUNUP.BAS tienen significados no documentados,
// y por eso se traducen de forma bastante directa para evitar confusiones:
privadodobladofAA1 = 0, dfAA2 = 0;// SUNUP.BAS A(2)
privadodobladofDD1 = 0, dfDD2 = 0;// SUNUP.BAS D(2)
privatedoubledfC0;// SUNUP.BAS C0
privatedoubledfK1;// SUNUP.BAS K1
privadodobledfP;// SUNUP.BAS P
privatedoubledfJ;// SUNUP.BAS J
privadodoubledfJ3;// SUNUP.BAS J3
privadodobledfA;// SUNUP.BAS A
privadodobladofA0, dfA2, dfA5;// SUNUP.BAS A0, A2, A5
privadodobledfD0, dfD1, dfD2, dfD5;// SUNUP.BAS D0, D1, D2, D5
privatedoubledfDA, dfDD;// SUNUP.BAS DA, DD
privadodobladofH0, dfH1, dfH2;// SUNUP.BAS H0, H1, H2
privadodobledfL0, dfL2;// SUNUP.BAS L0, L2
privadodobledfT, dfT0, dfTT;// SUNUP.BAS T, T0, TT
privadodobledfV0, dfV1, dfV2;// SUNUP.BAS V0, V1, V2
Zona horaria privada tz = TimeZone.getTimeZone( "GMT" );
/************************************************ * *******************************
*método:AmanecerAtardecer
************************************************** * *******************************
*
*Constructor de la clase SunriseSunset.
*
*------------------------------------------------- -------------------------*/
salida del sol puesta del sol (
doble dfLatIn,//latitud
doble dfLonIn,// longitud
Fecha fechaInputIn,// fecha
doble dfTimeZoneIn// zona horaria
)
{
// Copiar valores proporcionados como agrumentos a variables locales.
dfLat = dfLatIn;
dfLon = dfLonIn;
entrada de fecha = entrada de fecha;
dfTimeZone = dfTimeZoneIn;
// Llama al método para hacer los cálculos.
hacerCálculos();
} // fin del constructor de clase
/************************************************ * *******************************
*método:hacerCálculos
************************************************** * *******************************
*
*Método para realizar los cálculos realizados en SUNUP.BAS.
*
*------------------------------------------------- -------------------------*/
hacerCalculaciones nulas privadas()
{
intentar
{
// Desglose el día, mes y año a partir de la fecha proporcionada.
// (Esto es necesario para los algoritmos matemáticos).
dfmtYear = nuevo SimpleDateFormat( "aaaa");
dfmtYear.setLenient(falso);
dfmtYear.setTimeZone(tz);
dfmtMonth = nuevo SimpleDateFormat( "M" );
dfmtMonth.setLenient(falso);
dfmtMonth.setTimeZone(tz);
dfmtDay = nuevo SimpleDateFormat( "d" );
dfmtDay.setLenient(falso);
dfmtDay.setTimeZone(tz);
iAño = Integer.parseInt( dfmtYear.format( dateInput ) );
iMonth = Integer.parseInt( dfmtMonth.format( dateInput ) );
iDay = Integer.parseInt( dfmtDay.format( dateInput ) );
// Convertir horas de zona horaria a días decimales (SUNUP.BAS línea 50)
dfZonaHora = dfZonaHora / 24.0;
// NOTA: (7 de febrero de 2001) Aquí hay una parte no estándar de SUNUP.BAS:
// Este (y este algoritmo) asume que la zona horaria es
// oeste positivo, en lugar del oeste negativo estándar.
// Las clases que llamen a SunriseSunset asumirán que
// las zonas horarias se especifican en oeste negativo, por lo que aquí
// se cambia el signo para que funcione el algoritmo SUNUP:
dfZonaHora = -dfZonaHora;
// Convertir longitud a fracción (SUNUP.BAS línea 50)
dfLon = dfLon / 360,0;
// Convertir fecha del calendario a fecha juliana:
// Comprueba si es posterior a 1583: calendario gregoriano
// Cuando se declara, bGregorian se inicializa en falso.
// ** Considere crear una clase separada de esta función **.
if( iAño >= 1583 ) bGregoriano = verdadero;
// SUNUP.BAS 1210
dfJ = -Math.floor( 7.0// SUNUP usó INT, no piso
* (Matemáticas.piso(
(iMes+9.0)
/12.0
) + iAño
) / 4.0
)
// agrega SUNUP.BAS 1240 y 1250 para G = 0
+ Matemáticas.piso (iMes * 275,0/9,0)
+ iDía
+1721027.0
+ iAño * 367,0;
si(bgregoriano)
{
// SUNUP.BAS 1230
si ((iMes - 9,0) < 0,0) iSign = -1;
de lo contrario iSign = 1;
dfA = Math.abs(iMes - 9.0);
// SUNUP.BAS 1240 y 1250
dfJ3 = -Matemáticas.piso(
(
Matemáticas.piso(
Matemáticas.piso(iAño
+ (doble)iSign
* Matemáticas.piso (dfA / 7.0)
)
/100.0
) + 1,0
) * 0,75
);
// corrige dfJ como en SUNUP.BAS 1240 y 1250 para G = 1
dfJ = dfJ + dfJ3 + 2,0;
}
// SUNUP.BAS 1290
iJulian = (int)dfJ - 1;
// SUNUP.BAS 60 y 70 (ver también línea 1290)
dfT = (doble)iJulian - 2451545,0 + 0,5;
dfTT = dfT / 36525,0 + 1,0 // siglos desde 1900
//Calcular la hora sidérea local a las 0h en la zona horaria
// SUNUP.BAS 410 a 460
dfT0 = (dfT * 8640184,813 / 36525,0
+24110.5
+dfZona horaria*86636.6
+dfLon*86400.0
)
/86400,0;
dfT0 = dfT0 - Math.floor( dfT0 ); // NOTA: SUNUP.BAS usa INT();
dfT0 = dfT0 * 2,0 * Matemáticas PI;
// SUNUP.BAS 90
dfT = dfT + dfTimeZone;
// SUNUP.BAS 110: Obtener la posición del Sol
for( iCount=0; iCount<=1; iCount++ )// Realiza un bucle solo dos veces
{
// Calcular la ascensión recta y la declinación del Sol
// al inicio y al final de cada día.
// SUNUP.BAS 910 - 1160: Argumentos fundamentales
// de van Flandern y Pulkkinen, 1979
// declarar dobles temporales locales para los cálculos
doubledfGG;// SUNUP.BAS G
doubledfLL;// SUNUP.BAS L
doubledfSS;// SUNUP.BAS S
doubledfUU;// SUNUP.BAS U
doubledfVV;// SUNUP.BAS V
doubledfWW;// SUNUP.BAS W
dfLL = 0,779072 + 0,00273790931 * dfT;
dfLL = dfLL - Math.floor( dfLL );
dfLL = dfLL * 2.0 * Matemáticas.PI;
dfGG = 0,993126 + 0,0027377785 * dfT;
dfGG = dfGG - Math.floor( dfGG );
dfGG = dfGG * 2.0 * Matemáticas.PI;
dfVV = 0,39785 * Math.sin( dfLL )
- 0,01000 * Math.sin (dfLL - dfGG)
+ 0,00333 * Math.sin( dfLL + dfGG )
- 0,00021 * Math.sin( dfLL ) * dfTT;
dfUU=1
- 0.03349 * Matemáticas.cos(dfGG)
- 0,00014 * Math.cos (dfLL * 2,0)
+ 0,00008 * Math.cos(dfLL);
dfWW = - 0,00010
- 0.04129 * Math.sin (dfLL * 2.0)
+ 0,03211 * Matemáticas.sin( dfGG )
- 0,00104 * Math.sin( 2,0 * dfLL - dfGG )
- 0,00035 * Math.sin( 2,0 * dfLL + dfGG )
- 0,00008 * Math.sin( dfGG ) * dfTT;
// Calcular RA y Dec de Sun; SUNUP.BAS 1120 - 1140
dfSS = dfWW / Math.sqrt( dfUU - dfVV * dfVV );
dfA5 = dfLL
+ Math.atan( dfSS / Math.sqrt( 1.0 - dfSS * dfSS ));
dfSS = dfVV / Math.sqrt( dfUU );
dfD5 = Math.atan( dfSS / Math.sqrt( 1 - dfSS * dfSS ));
// Establecer valores e incrementar t
si (iCount == 0) // SUNUP.BAS 125
{
dfAA1 = dfA5;
dfDD1 = dfD5;
}
más// SUNUP.BAS 145
{
dfAA2 = dfA5;
dfDD2 = dfD5;
}
dfT = dfT + 1,0; // SUNUP.BAS 130
}// final del bucle For Obtener la posición del sol
si ( dfAA2 < dfAA1 ) dfAA2 = dfAA2 + 2.0 * Math.PI;
// SUNUP.BAS 150
dfZenith = Math.PI * 90.833 / 180.0;// SUNUP.BAS 160
dfSinLat = Math.sin( dfLat * Math.PI / 180.0 );// SUNUP.BAS 170
dfCosLat = Math.cos( dfLat * Math.PI / 180.0 );// SUNUP.BAS 170
dfA0 = dfAA1;// SUNUP.BAS 190
dfD0 = dfDD1;// SUNUP.BAS 190
dfDA = dfAA2 - dfAA1; // SUNUP.BAS 200;
dfDD = dfDD2 - dfDD1; // SUNUP.BAS 200;
dfK1 = 15,0 * 1,0027379 * Math.PI / 180,0;// SUNUP.BAS 330
// Inicializa las horas de salida y puesta del sol, y otras variables
// hr y min se establecen en tiempos imposibles para que los errores sean obvios
dfHoraAumento = 99,0;
dfMinRise = 99,0;
dfHourSet = 99,0;
dfMinSet = 99,0;
dfV0 = 0.0;// inicialización implícita por ausencia en SUNUP.BAS
dfV2 = 0.0;// inicialización implícita por ausencia en SUNUP.BAS
// Prueba cada hora para ver si el Sol cruza el horizonte
// y hacia dónde se dirige.
para( iCount=0; iCount<24; iCount++ )// SUNUP.BAS 210
{
doubletempA;// SUNUP.BAS A
doubletempB;// SUNUP.BAS B
doubletempD;// SUNUP.BAS D
doubletempE;// SUNUP.BAS E
dfC0 = (doble)iCount;
dfP = ( dfC0 + 1.0 ) / 24.0;// SUNUP.BAS 220
dfA2 = dfAA1 + dfP * dfDA // SUNUP.BAS 230;
dfD2 = dfDD1 + dfP * dfDD // SUNUP.BAS 230
dfL0 = dfT0 + dfC0 * dfK1;// SUNUP.BAS 500
dfL2 = dfL0 + dfK1; // SUNUP.BAS 500;
dfH0 = dfL0 - dfA0; // SUNUP.BAS 510;
dfH2 = dfL2 - dfA2 // SUNUP.BAS 510;
// ángulo horario a la media hora
dfH1 = ( dfH2 + dfH0 ) / 2.0;// SUNUP.BAS 520
// declinación a la media hora
dfD1 = ( dfD2 + dfD0 ) / 2.0;// SUNUP.BAS 530
// Establece el valor de dfV0 solo si es la primera hora,
// de lo contrario, se configurará en el último dfV2 (SUNUP.BAS 250)
si (iCount == 0) // SUNUP.BAS 550
{
dfV0 = dfSinLat * Math.sin( dfD0 )
+ dfCosLat * Math.cos( dfD0 ) * Math.cos( dfH0 )
- Math.cos( dfZenith );// SUNUP.BAS 560
}
demás
dfV0 = dfV2;// Es decir, dfV2 de la hora anterior.
dfV2 = dfSinLat * Math.sin( dfD2 )
+ dfCosLat * Math.cos( dfD2 ) * Math.cos( dfH2 )
- Math.cos( dfZenith );// SUNUP.BAS 570
// si dfV0 y dfV2 tienen el mismo signo, entonces continúa con la siguiente hora
si (
( dfV0 >= 0.0 && dfV2 >= 0.0 )// ambos son positivos
||// o
( dfV0 < 0.0 && dfV2 < 0.0 ) // ambos son negativos
)
{
// Romper la iteración y proceder a la prueba la próxima hora
dfA0 = dfA2;// SUNUP.BAS 250
dfD0 = dfD2;// SUNUP.BAS 250
continuar;// SUNUP.BAS 610
}
dfV1 = dfSinLat * Math.sin( dfD1 )
+ dfCosLat * Math.cos( dfD1 ) * Math.cos( dfH1 )
- Math.cos( dfZenith );// SUNUP.BAS 590
tempA = 2,0 * dfV2 - 4,0 * dfV1 + 2,0 * dfV0;
// SUNUP.BAS 600
tempB = 4.0 * dfV1 - 3.0 * dfV0 - dfV2 // SUNUP.BAS 600;
tempD = tempB * tempB - 4.0 * tempA * dfV0;// SUNUP.BAS 610
si (tempD < 0,0)
{
// Romper la iteración y proceder a la prueba la próxima hora
dfA0 = dfA2;// SUNUP.BAS 250
dfD0 = dfD2;// SUNUP.BAS 250
continuar;// SUNUP.BAS 610
}
tempD = Math.sqrt( tempD );// SUNUP.BAS 620
// Determinar la aparición del amanecer o del atardecer.
// Las banderas para identificar ocurrencia durante este día son
// bSunriseToday y bSunsetToday, y se inicializan en false.
// Estos se establecen como verdaderos sólo si ocurre el amanecer o el atardecer
// en cualquier punto del ciclo horario. Nunca se establece en falso.
// Banderas para identificar ocurrencia durante esta hora:
bSunrise = false; // restablecer antes de la prueba
bSunset = false; // restablecer antes de la prueba
if ( dfV0 < 0.0 && dfV2 > 0.0 )// el amanecer ocurre esta hora
{
bAmanecer = verdadero; // AMANECER.BAS 640
bSunriseToday = true; // el amanecer ocurrió hoy
}
if ( dfV0 > 0.0 && dfV2 < 0.0 )// la puesta del sol ocurre esta hora
{
bAtardecer = verdadero; // SUNUP.BAS 660
bSunsetToday = true;// el atardecer ocurrió hoy
}
tempE = (tempD - tempB) / (2.0 * tempA);
si (tempE > 1,0 || tempE < 0,0 )// SUNUP.BAS 670, 680
tempE = (-tempD - tempB) / (2.0 * tempA);
// Establecer valores de hora y minutos de puesta o salida del sol
// sólo si el amanecer/la puesta ocurrió a esta hora.
si(bamanecer)
{
dfHourRise = Math.floor( dfC0 + tempE + 1.0/120.0 );
dfMinRise = Matemáticas.piso(
(dfC0 + tempE + 1,0/120,0
-dfHourRise
)
* 60.0
);
}
si(bpuesta del sol)
{
dfHourSet = Math.floor( dfC0 + tempE + 1.0/120.0);
dfMinSet = Matemáticas.piso(
(dfC0 + tempE + 1,0/120,0
-dfHourSet
)
* 60.0
);
}
// Cambiar la configuración de las variables para el siguiente ciclo
dfA0 = dfA2;// SUNUP.BAS 250
dfD0 = dfD2;// SUNUP.BAS 250
}//fin de prueba de bucle cada hora para un evento
// Después de haber comprobado todas las horas, configurar banderas si no hay subida o puesta
// bSunUpAllDay y bSundownAllDay se inicializan como falso
si ( !bAmanecerHoy && !bAtardecerHoy )
{
si (dfV2 < 0,0)
bSunDownAllDay = verdadero;
demás
bSunUpAllDay = verdadero;
}
// Cargar fechaAmanecer con datos
dfmtDateTime = new SimpleDateFormat( "d M aaaa HH:mm z" );
si(bamanecerhoy)
{
fechaAmanecer = dfmtDateTime.parse(iDay
+ " " + iMes
+ " " + iAño
+ " " + (int)dfHoraAumento
+ ":" + (int)dfMinRise
+ "GMT" );
}
// Cargar fechaAtardecer con datos
si (bpuesta del sol hoy)
{
fechaAtardecer = dfmtDateTime.parse(iDay
+ " " + iMes
+ " " + iAño
+ " " + (int)dfHourSet
+ ":" + (int)dfMinSet
+ "GMT" );
}
} // fin del intento
// Detectar errores
captura (ParseException e)
{
System.out.println( "/nNo se puede analizar la fecha" );
System.out.println(e);
Sistema.salir(1);
} // fin de la captura
}
/************************************************ * *******************************
*método:getSunrise()
************************************************** * *******************************
*
* Obtiene la fecha y hora del amanecer. Si no hay amanecer, devuelve nulo.
*
*Miembro de la clase SunriseSunset
*
*------------------------------------------------- --------------------------- */
Fecha pública getSunrise()
{
si(bamanecerhoy)
retorno(fechaAmanecer);
demás
retorno (nulo);
}
/************************************************ * *******************************
*método:getSunset()
************************************************** * *******************************
*
* Obtiene la fecha y hora del atardecer. Si no hay atardecer, devuelve nulo.
*
*Miembro de la clase SunriseSunset
*
*------------------------------------------------- --------------------------- */
Fecha pública getSunset()
{
si(bpuesta del sol hoy)
retorno(fechaAtardecer);
demás
retorno (nulo);
}
/************************************************ * *******************************
*método:isSunrise()
************************************************** * *******************************
*
* Devuelve un booleano identificando si hubo amanecer.
*
*Miembro de la clase SunriseSunset
*
*------------------------------------------------- --------------------------- */
booleano público esSunrise()
{
retorno( bAmanecerHoy );
}
/************************************************ * *******************************
*método:isSunset()
************************************************** * *******************************
*
* Devuelve un booleano identificando si hubo atardecer.
*
*Miembro de la clase SunriseSunset
*
*------------------------------------------------- --------------------------- */
booleano público esSunset()
{
retorno(bAtardecerHoy);
}
/************************************************ * *******************************
*método:isSunUp()
************************************************** * *******************************
*
* Devuelve un booleano que identifica si el sol sale todo el día.
*
*Miembro de la clase SunriseSunset
*
*------------------------------------------------- --------------------------- */
público booleano esSunUp()
{
retorno (bSunUpAllDay);
}
/************************************************ * *******************************
*método:isSunDown()
************************************************** * *******************************
*
* Devuelve un booleano que identifica si el sol se ha puesto durante todo el día.
*
*Miembro de la clase SunriseSunset
*
*------------------------------------------------- --------------------------- */
público booleano esSunDown()
{
retorno (bSunDownAllDay);
}
/************************************************ * *******************************
*método:esDía()
************************************************** * *******************************
*
* Devuelve un booleano identificando si es de día a la hora contenida en
*el objeto Fecha pasó a SunriseSunset en construcción.
*
*Miembro de la clase SunriseSunset
*
*------------------------------------------------- --------------------------- */
booleano público es diurno()
{
// Determinar si es de día (al amanecer o más tarde)
//o de noche (al atardecer o más tarde) en el lugar de interés
//pero expresado en la zona horaria solicitada.
if ( bSunriseToday && bSunsetToday ) // amanecer y atardecer
{
if (fechaAmanecer.antes(fechaAtardecer))// amanecer <atardecer
{
si (
(
fechaInput.después(fechaAmanecer)
fechaInput.equals(fechaAmanecer)
)
&&
fechaInput.antes(fechaAtardecer)
)
bDiurno = verdadero;
demás
bDiurno = falso;
}
else // el amanecer llega después del atardecer (en zonas horarias opuestas)
{
si (
(
fechaInput.después(fechaAmanecer)
fechaInput.equals(fechaAmanecer)
)
||// utilizar OR en lugar de AND
fechaInput.antes(fechaAtardecer)
)
bDiurno = verdadero;
demás
bDiurno = falso;
}
}
else if (bSunUpAllDay) // sale sol todo el día
bDiurno = verdadero;
else if (bSunDownAllDay)// el sol está puesto todo el día
bDiurno = falso;
else if (bSunriseToday) // amanecer pero no atardecer
{
si (fecha de entrada.antes (fecha del amanecer))
bDiurno = falso;
demás
bDiurno = verdadero;
}
else if (bSunsetToday) // atardecer pero no amanecer
{
si (fechaEntrada.antes(fechaAtardecer))
bDiurno = verdadero;
demás
bDiurno = falso;
}
else bDaytime = false // esto nunca debería ejecutarse
return(bDía);
}
} // fin de clase
/*------------------------------------------------ --------------------------
*fin de clase
*------------------------------------------------- -------------------------*/