Obtenha os horários locais do nascer e do pôr do sol com base na latitude e longitude e na data atual. Uma poderosa pesquisa no Google me permitiu encontrar rapidamente uma classe java escrita por um estrangeiro.
Poste o código diretamente aqui:
Copie o código do código da seguinte forma:
/************************************************ * ******************************
*
*SunriseSunset.java
*
************************************************** *******************************
*
* Classe Java: SunriseSunset
*
*Esta classe Java faz parte de uma coleção de classes desenvolvidas para o
*leitura e processamento de dados oceanográficos e meteorológicos coletados
*desde 1970 por bóias e estações ambientais Este é um conjunto de dados.
*mantido pelo Centro Nacional de Dados Oceanográficos e é público
*disponível. Essas classes Java foram escritas para o Departamento Ambiental dos EUA.
*Laboratório Nacional de Pesquisa de Exposição da Agência de Proteção sob contrato
*Nº GS-10F-0073K com Neptune and Company de Los Alamos, Novo México.
*
*Propósito:
*
* Esta classe Java realiza cálculos para determinar o tempo de
*nascer e pôr do sol com latitude, longitude e data.
*
*Entradas:
*
* Latitude, longitude, data/hora e fuso horário.
*
*Saídas:
*
* Hora local do nascer e do pôr do sol calculada pelo
*programa.
*Se não ocorrer nenhum nascer do sol ou pôr do sol, ou se o sol estiver alto o dia todo
* ou inativo o dia todo, os valores booleanos apropriados são definidos.
*Um booleano é fornecido para identificar se o horário fornecido é durante o dia.
*
*Os valores acima são acessados pelos seguintes métodos:
*
*DategetSunrise() retorna a data/hora do nascer do sol
*DategetSunset() retorna a data/hora do pôr do sol
*booleanisSunrise() retorna verdadeiro se houve nascer do sol, caso contrário, falso
*booleanisSunset() retorna verdadeiro se houve pôr do sol, caso contrário, falso
*booleanisSunUp() retorna verdadeiro se o sol nascer o dia todo, caso contrário, falso
*booleanisSunDown() retorna verdadeiro se o sol estiver posto o dia todo, caso contrário, falso
*booleanisDaytime() retorna verdadeiro se o sol nascer naquele horário
*especificado, caso contrário falso
*
* Classes necessárias da biblioteca Java:
*
*java.util.Date
*java.text.SimpleDateFormat
*java.text.ParseException;
*java.math.BigDecimal;
*
* Pacote do qual esta classe é membro:
*
*padrão
*
* Limitações conhecidas:
*
*Presume-se que os dados fornecidos estão dentro dos intervalos válidos
*(ou seja, latitude entre -90 e +90, longitude entre 0 e 360,
*uma data válida e fuso horário entre -14 e +14.
*
*Compatibilidade:
*
* Java 1.1.8
*
* Referências:
*
*Os algoritmos matemáticos usados neste programa são padronizados
*após aqueles desenvolvidos por Roger Sinnott em seu programa BASIC,
*SUNUP.BAS, publicado na revista Sky & Telescope:
*Sinnott, Roger W. "Nascer e pôr do sol: um desafio"
*Sky & Telescope, agosto de 1994, p.84-85
*
*A seguir está um índice cruzado de variáveis usadas no SUNUP.BAS.
*Uma definição única de reutilização múltipla de nomes de variáveis em
*SUNUP.BAS foi esclarecido com diversas definições neste programa.
*
*SUNUP.BASesta aula
*
*Adfa
*A(2)dfAA1, dfAA2
*A0dfA0
*A2dfA2
*A5dfA5
*AZNão usado
*CdfCosLat
*C0dfC0
*DiDia
*D(2)dfDD1, dfDD2
*D0dfD0
*D1dfD1
*D2dfD2
*D5dfD5
*D7Não usado
*DAdfDA
*DDdfDD
*GbGregorian, dfGG
*HdfTimeZone
*H0dfH0
*H1dfH1
*H2dfH2
*H3dfHourRise, dfHourSet
*H7Não usado
*JdfJ
*J3dfJ3
*K1dfK1
*LdfLL
*L0dfL0
*L2dfL2
*L5dfLon
*MiMês
*M3dfMinRise, dfMinSet
*N7Não utilizado
*PdfP
*SiSign, dfSinLat, dfSS
*TdfT
*T0dfT0
*T3 não usado
*TTdfTT
*UdfUU
*VdfVV
*V0dfV0
*V1dfV1
*V2dfV2
*WdfWW
*AnoAno
*ZdfZenith
*Z0dfTimeZone
*
*
*Autor/Empresa:
*
* JDT: John Tauxe, Netuno e Companhia
*JMG: Jo Marie Green
*
* Registro de alterações:
*
*data ver por descrição da mudança
*_________ _____ _______________________________________________
* 5 de janeiro de 01 0.006 JDTExposto de ssapp.java v.
*11 Jan 01 0.007 JDTMinor modificações nos comentários com base em
*material de Sinnott, 1994.
* 7 de fevereiro de 01 0,008 JDTFixed fuso horário inverso O padrão é esse.
* o fuso horário local é especificado em horas a LESTE de
* Greenwich, então EST seria -5, por exemplo.
* Por alguma razão, SUNUP.BAS faz isso ao contrário
* (provavelmente uma perspectiva americanacêntrica) e
* SunriseSunset adotou essa convenção.
* Portanto, o sinal na matemática é alterado.
* 7 de fevereiro de 01 0,009 JDTBem, isso atrapalhou o cálculo do azimute...
* Removidos os cálculos de azimute.
*14 de fevereiro de 01 0,010 JDT Adicionada capacidade de aceitar um horário (HH:mm) em
* dateInput e decida se esse horário é diurno
*ou noturno.
*27 de fevereiro de 01 0.011 JDT Adicionados métodos de acesso no lugar de ter público
* variáveis para obter resultados.
*28 de fevereiro de 01 0.012 JDTClista limpa de classes importadas.
*28 de março de 01 1.10 JDT Versão final que acompanha o produto 1b.
* 4 de abril de 01 1.11 Lógica JDTMoved com suporte a .isDaytime no método.
* Cálculos movidos para fora do construtor.
* 01 de maio de 01 1.12 JMG Adicionada designação 'GMT' e linhas de teste.
* 16 de maio de 01 1.13 JDT Adicionado setLenient( false ) e setTimeZone( tz )
* para dfmtDay, dfmtMonth e dfmtYear em
*fazerCálculos.
* 27 de junho de 01 1.14 JDTRemoveu a dependência de StationConstants (GMT).
*13 de agosto de 01 1.20 JDT Versão final que acompanha o produto 1c.
* 6 de setembro de 01 1.21 JDTT revisão completa de código e comentários.
*21 Set 01 1.30 JDT Versão final que acompanha o produto 2.
*17 Dez 01 1.40 JDTVersion acompanha a entrega final.
*
*------------------------------------------------ - -------------------------*/
//Importa classes e pacotes necessários
importar java.util.Date;
importar java.text.SimpleDateFormat;
importar java.text.ParseException;
importar java.math.BigDecimal;
importar java.util.TimeZone;
/************************************************ * ******************************
*classe:Classe SunriseSunset
************************************************** *******************************
*
* Esta classe Java realiza cálculos para determinar o tempo de
*nascer e pôr do sol com latitude, longitude e data.
*
*Presume-se que os dados fornecidos estão dentro dos intervalos válidos
*(ou seja, latitude entre -90 e +90, longitude entre 0 e 360,
*uma data válida e fuso horário entre -14 e +14.
*
*------------------------------------------------ - -------------------------*/
aula públicaSunriseSunset
{
//Declara e inicializa variáveis
private doubledfLat; // latitude do usuário
private doubledfLon;//latitude do usuário
private DatedateInput; // data/hora do usuário
private doubledfTimeZone; // fuso horário do usuário
private DatedateSunrise; // data e hora do nascer do sol
private DatedateSunset; //data e hora do pôr do sol
private booleanbSunriseToday = false; // sinaliza para o nascer do sol nesta data
private booleanbSunsetToday = false; // sinaliza o pôr do sol nesta data
private booleanbSunUpAllDay = false; // sinaliza para nascer do sol o dia todo
private booleanbSunDownAllDay = false; // sinaliza para pôr do sol o dia todo
private booleanbDaytime = false; // sinalizador para o dia, dado
//hora e min em dateInput
private booleanbSunrise = false; // nascer do sol durante a hora verificada
private booleanbSunset = false; // pôr do sol durante a hora verificada
private booleanbGregorian = false; // sinalizador para calendário gregoriano
privado intiJulian;//dia juliano
privateintiYear;// ano da data de interesse
privateintiMonth;// mês da data de interesse
privateintiDay; // dia da data de interesse
privateintiCount;// um contador simples
privateintiSign;// SUNUP.BAS: S
private doubledfHourRise, dfHourSet;// hora do evento: SUNUP.BAS H3
private doubledfMinRise, dfMinSet;//minuto do evento: SUNUP.BAS M3
privatedoubledfSinLat, dfCosLat;// sen e cos da latitude
privatedoubledfZenith;// SUNUP.BAS Z: Zenith
privateSimpleDateFormat dfmtDate;// formatação apenas para data
privateSimpleDateFormat dfmtDateTime;// formatação para data e hora
privateSimpleDateFormat dfmtYear;// formatação para ano
privateSimpleDateFormat dfmtMonth;// formatação para mês
privateSimpleDateFormat dfmtDay;// formatação para o dia
// Muitas variáveis em SUNUP.BAS têm significados não documentados,
// e assim são traduzidos diretamente para evitar confusão:
privatedoubledfAA1 = 0, dfAA2 = 0;// SUNUP.BAS A(2)
privatedoubledfDD1 = 0, dfDD2 = 0;// SUNUP.BAS D(2)
privatedoubledfC0;// SUNUP.BAS C0
privatedoubledfK1;// SUNUP.BAS K1
privatedoubledfP;// SUNUP.BAS P
privatedoubledfJ;// SUNUP.BAS J
privatedoubledfJ3;// SUNUP.BAS J3
privatedoubledfA;// SUNUP.BAS A
privatedoubledfA0, dfA2, dfA5;// SUNUP.BAS A0, A2, A5
privatedoubledfD0, dfD1, dfD2, dfD5;// SUNUP.BAS D0, D1, D2, D5
privatedoubledfDA, dfDD;// SUNUP.BAS DA, DD
privatedoubledfH0, dfH1, dfH2;// SUNUP.BAS H0, H1, H2
privatedoubledfL0, dfL2;// SUNUP.BAS L0, L2
privatedoubledfT, dfT0, dfTT;// SUNUP.BAS T, T0, TT
privatedoubledfV0, dfV1, dfV2;// SUNUP.BAS V0, V1, V2
fuso horário privado tz = TimeZone.getTimeZone("GMT");
/************************************************ * ******************************
*método:SunriseSunset
************************************************** *******************************
*
*Construtor para a classe SunriseSunset.
*
*------------------------------------------------ - -------------------------*/
Nascer do solPôr do sol(
duplo dfLatIn, //latitude
duplo dfLonIn, // longitude
Data dateInputIn, // data
duplo dfTimeZoneIn // fuso horário
)
{
// Copia os valores fornecidos como argumentos para variáveis locais.
dfLat = dfLatIn;
dfLon = dfLonIn;
dataInput = dataInputIn;
dfTimeZone = dfTimeZoneIn;
//Chama o método para fazer os cálculos.
doCálculos();
} // fim do construtor da classe
/************************************************ * ******************************
*método:fazerCálculos
************************************************** *******************************
*
*Método para realizar os cálculos feitos no SUNUP.BAS.
*
*------------------------------------------------ - -------------------------*/
private void doCalculations()
{
tentar
{
// Separe dia, mês e ano a partir da data fornecida.
// (Isso é necessário para os algoritmos matemáticos.)
dfmtYear = new SimpleDateFormat("aaaa");
dfmtYear.setLenient(falso);
dfmtYear.setTimeZone(tz);
dfmtMonth = new SimpleDateFormat("M");
dfmtMonth.setLenient(falso);
dfmtMonth.setTimeZone(tz);
dfmtDay = new SimpleDateFormat("d");
dfmtDay.setLenient(falso);
dfmtDay.setTimeZone(tz);
iYear = Integer.parseInt(dfmtYear.format(dateInput));
iMonth = Integer.parseInt(dfmtMonth.format(dateInput));
iDay = Integer.parseInt(dfmtDay.format(dateInput));
// Converte as horas do fuso horário em dias decimais (linha 50 do SUNUP.BAS)
dfTimeZone = dfTimeZone / 24.0;
// NOTA: (7 de fevereiro de 2001) Aqui está uma parte não padrão do SUNUP.BAS:
// Ele (e este algoritmo) assume que o fuso horário é
// oeste positivo, em vez do oeste negativo padrão.
//As classes que chamam SunriseSunset assumirão que
// os fusos horários são especificados em oeste negativo, então aqui o
// o sinal é alterado para que o algoritmo SUNUP funcione:
dfTimeZone = -dfTimeZone;
// Converte longitude em fração (linha 50 SUNUP.BAS)
dfLon = dfLon/360,0;
// Converte a data do calendário em data juliana:
// Verifica se é posterior a 1583: calendário gregoriano
// Quando declarado, bGregorian é inicializado como false.
// ** Considere criar uma classe separada desta função **.
if(iAno >= 1583) bGregoriano = verdadeiro;
//SUNUP.BAS 1210
dfJ = -Math.floor( 7.0// SUNUP usou INT, não floor
* (Math.floor(
(iMês+9,0)
/12.0
) + iAno
) / 4,0
)
//adiciona SUNUP.BAS 1240 e 1250 para G = 0
+ Math.floor (iMês * 275,0/9,0)
+ iDia
+1721027,0
+ iAno * 367,0;
if(bGregoriano)
{
// SUNUP.BAS 1230
if (( iMês - 9,0 ) < 0,0 ) iSign = -1;
senão iSign = 1;
dfA = Math.abs(iMês - 9.0);
// SUNUP.BAS 1240 e 1250
dfJ3 = -Math.floor(
(
Math.floor(
Math.floor(iAno
+ (duplo)iSign
* Math.floor (dfA/7.0)
)
/100,0
) + 1,0
) * 0,75
);
// corrige dfJ como em SUNUP.BAS 1240 e 1250 para G = 1
dfJ = dfJ + dfJ3 + 2,0;
}
// SUNUP.BAS 1290
iJulian = (int)dfJ - 1;
// SUNUP.BAS 60 e 70 (ver também linha 1290)
dfT = (duplo)iJulian - 2451545,0 + 0,5;
dfTT = dfT / 36525,0 + 1,0; // séculos desde 1900;
// Calcula a hora sideral local às 0h no fuso horário
// SUNUP.BAS 410 a 460
dfT0 = (dfT * 8640184,813/36525,0
+24110,5
+dfFuso Horário*86636,6
+dfLon*86400,0
)
/86400,0;
dfT0 = dfT0 - Math.floor( dfT0 ); // NOTA: SUNUP.BAS usa INT();
dfT0 = dfT0 * 2,0 * Math.PI;
// SUNUP.BAS 90
dfT = dfT + dfTimeZone;
// SUNUP.BAS 110: Obtenha a posição da Sun
for( iCount=0; iCount<=1; iCount++ )// Loop thru apenas duas vezes
{
// Calcula a ascensão reta e a declinação do Sol
// no início e no final de cada dia.
// SUNUP.BAS 910 - 1160: Argumentos fundamentais
// de van Flandern e Pulkkinen, 1979
//declara duplicações temporárias locais para cálculos
dobradofGG;// SUNUP.BAS G
dobradofLL;// SUNUP.BAS L
dobradofSS;// SUNUP.BAS S
dobradofUU;// SUNUP.BAS U
dobradofVV;// SUNUP.BAS V
dobradofWW;// SUNUP.BAS W
dfLL = 0,779072 + 0,00273790931 *dfT;
dfLL = dfLL - Math.floor(dfLL);
dfLL = dfLL * 2,0 * Math.PI;
dfGG = 0,993126 + 0,0027377785 *dfT;
dfGG = dfGG - Math.floor(dfGG);
dfGG = dfGG * 2,0 * Math.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 * Math.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 * Math.sin(dfGG)
- 0,00104 * Math.sin(2,0 * dfLL - dfGG)
- 0,00035 * Math.sin (2,0 * dfLL + dfGG)
- 0,00008 * Math.sin(dfGG) * dfTT;
// Calcula RA e Dec da Sun;
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 ));
//Definir valores e incrementar t
if (iCount == 0) // SUNUP.BAS 125
{
dfAA1 = dfA5;
dfDD1 = dfD5;
}
outro // SUNUP.BAS 145
{
dfAA2 = dfA5;
dfDD2 = dfD5;
}
dfT = dfT + 1,0;//SUNUP.BAS 130
} // fim do loop for Obter posição do Sol
if (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 os horários do nascer e do pôr do sol e outras variáveis
// horas e minutos são definidos para tempos impossíveis para tornar os erros óbvios
dfHourRise = 99,0;
dfMinRise = 99,0;
dfHourSet = 99,0;
dfMinSet = 99,0;
dfV0 = 0.0;// inicialização implícita por ausência em SUNUP.BAS
dfV2 = 0.0;// inicialização implícita por ausência em SUNUP.BAS
//Teste a cada hora para ver se o Sol cruza o horizonte
// e para onde está indo.
for( 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 = (duplo)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 horário em meia hora
dfH1 = (dfH2 + dfH0) / 2,0;// SUNUP.BAS 520
// declinação em meia hora
dfD1 = ( dfD2 + dfD0 ) / 2.0;// SUNUP.BAS 530
// Define o valor de dfV0 somente se esta for a primeira hora,
// caso contrário, será definido para o último dfV2 (SUNUP.BAS 250)
if (iCount == 0) // SUNUP.BAS 550
{
dfV0 = dfSinLat * Math.sin(dfD0)
+ dfCosLat * Math.cos( dfD0 ) * Math.cos( dfH0 )
- Math.cos (dfZenith); // SUNUP.BAS 560
}
outro
dfV0 = dfV2;// Ou seja, dfV2 da hora anterior.
dfV2 = dfSinLat * Math.sin(dfD2)
+ dfCosLat * Math.cos( dfD2 ) * Math.cos( dfH2 )
- Math.cos (dfZenith); // SUNUP.BAS 570
// se dfV0 e dfV2 tiverem o mesmo sinal, então prossiga para a próxima hora
se (
( dfV0 >= 0,0 && dfV2 >= 0,0 )// ambos são positivos
||// ou
( dfV0 < 0,0 && dfV2 < 0,0 ) // ambos são negativos
)
{
// Interrompe a iteração e prossegue para o teste na 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;
tempD = tempB * tempB - 4,0 * tempA * dfV0;// SUNUP.BAS 610
se (tempD <0,0)
{
// Interrompe a iteração e prossegue para o teste na próxima hora
dfA0 = dfA2;// SUNUP.BAS 250
dfD0 = dfD2;// SUNUP.BAS 250
continuar;// SUNUP.BAS 610
}
tempD = Math.sqrt( tempD );// SUNUP.BAS 620
// Determina a ocorrência do nascer ou pôr do sol.
// Flags para identificar ocorrência durante este dia são
// bSunriseToday e bSunsetToday, e são inicializados como falso.
// Estes são definidos como verdadeiros apenas se ocorrer o nascer ou o pôr do sol
// em qualquer ponto do loop horário Nunca defina como false.
// Flags para identificar ocorrência neste horário:
bSunrise = false; //reset antes do teste
bSunset = false; //reset antes do teste
if (dfV0 < 0.0 && dfV2 > 0.0 )// o nascer do sol ocorre nesta hora
{
bSunrise = true; // SUNUP.BAS 640
bSunriseToday = true; // o nascer do sol ocorreu hoje
}
if (dfV0 > 0.0 && dfV2 < 0.0 )// o pôr do sol ocorre nesta hora
{
bPôr do sol = true; // SUNUP.BAS 660
bSunsetToday = true;// o pôr do sol ocorreu hoje
}
tempE = (tempD-tempB) / (2,0*tempA);
if (tempE > 1,0 || tempE < 0,0) // SUNUP.BAS 670, 680
tempE = (-tempD-tempB) / (2,0 * tempA);
// Define valores de hora e minuto do pôr do sol ou nascer do sol
// somente se o nascer/pôr do sol ocorreu nesta hora.
if(bnascer do sol)
{
dfHourRise = Math.floor (dfC0 + tempE + 1,0/120,0);
dfMinRise = Math.floor(
(dfC0 + tempE + 1,0/120,0
-dfHourRise
)
* 60,0
);
}
if(bPôr do sol)
{
dfHourSet = Math.floor (dfC0 + tempE + 1,0/120,0);
dfMinSet = Math.floor(
(dfC0 + tempE + 1,0/120,0
- dfHourSet
)
* 60,0
);
}
// Altera as configurações das variáveis para o próximo loop
dfA0 = dfA2;// SUNUP.BAS 250
dfD0 = dfD2;// SUNUP.BAS 250
}//fim do loop testando a cada hora para um evento
// Depois de verificar todas as horas, definir sinalizadores se não houver subida ou definição
// bSunUpAllDay e bSundownAllDay são inicializados como falso
if ( !bSunriseHoje && !bSunsetHoje )
{
se (dfV2 < 0,0)
bSunDownAllDay = verdadeiro;
outro
bSunUpAllDay = verdadeiro;
}
// Carrega dateSunrise com dados
dfmtDateTime = new SimpleDateFormat( "d M yyyy HH:mm z" );
if(bSunriseHoje)
{
dataSunrise = dfmtDateTime.parse(iDay
+ " " + iMês
+ " " + iAno
+ " " + (int)dfHourRise
+ ":" + (int)dfMinRise
+ "GMT");
}
// Carrega dateSunset com dados
if(bPôr do sol hoje)
{
dateSunset = dfmtDateTime.parse(iDay
+ " " + iMês
+ " " + iAno
+ " " + (int)dfHourSet
+ ":" + (int)dfMinSet
+ "GMT");
}
} // fim da tentativa
//Captura erros
catch(ParseException e)
{
System.out.println( "/nNão é possível analisar a data");
System.out.println(e);
Sistema.exit(1);
} // fim da captura
}
/************************************************ * ******************************
*método:getSunrise()
************************************************** *******************************
*
* Obtém a data e hora do nascer do sol. Se não houver nascer do sol, retorna nulo.
*
*Membro da turma SunriseSunset
*
*------------------------------------------------ - --------------------------- */
Data pública getSunrise()
{
if(bSunriseHoje)
return(datanascer do sol);
outro
retornar(nulo);
}
/************************************************ * ******************************
*método:getSunset()
************************************************** *******************************
*
* Obtém a data e hora do pôr do sol. Se não houver pôr do sol, retorna nulo.
*
*Membro da turma SunriseSunset
*
*------------------------------------------------ - --------------------------- */
Data pública getSunset()
{
if(bPôr do sol hoje)
return(dataPôr do sol);
outro
retornar(nulo);
}
/************************************************ * ******************************
*método:isSunrise()
************************************************** *******************************
*
* Retorna um booleano identificando se houve nascer do sol.
*
*Membro da turma SunriseSunset
*
*------------------------------------------------ - --------------------------- */
booleano público éSunrise()
{
return(bSunriseHoje);
}
/************************************************ * ******************************
*método:isSunset()
************************************************** *******************************
*
* Retorna um booleano identificando se houve pôr do sol.
*
*Membro da turma SunriseSunset
*
*------------------------------------------------ - --------------------------- */
booleano público isSunset()
{
return(bSunsetHoje);
}
/************************************************ * ******************************
*método:isSunUp()
************************************************** *******************************
*
* Retorna um booleano que identifica se o sol nasce o dia todo.
*
*Membro da turma SunriseSunset
*
*------------------------------------------------ - --------------------------- */
booleano público isSunUp()
{
return(bSunUpAllDay);
}
/************************************************ * ******************************
*método:isSunDown()
************************************************** *******************************
*
* Retorna um booleano que identifica se o sol se põe o dia todo.
*
*Membro da turma SunriseSunset
*
*------------------------------------------------ - --------------------------- */
booleano público isSunDown()
{
return(bSunDownAllDay);
}
/************************************************ * ******************************
*método:isDaytime()
************************************************** *******************************
*
* Retorna um booleano identificando se é dia na hora contida em
*o objeto Date passado para SunriseSunset na construção.
*
*Membro da turma SunriseSunset
*
*------------------------------------------------ - --------------------------- */
booleano público isDaytime()
{
// Determina se é dia (ao nascer do sol ou mais tarde)
//ou à noite (ao pôr do sol ou mais tarde) no local de interesse
//mas expresso no fuso horário solicitado.
if ( bSunriseToday && bSunsetToday ) // nascer e pôr do sol
{
if (dataSunrise.before(dateSunset)) // nascer do sol <pôr do sol
{
se (
(
dateInput.after(dataSunrise)
dateInput.equals(dataSunrise)
)
&&
dateInput.before(dataPôr do sol)
)
bDaytime = verdadeiro;
outro
bDaytime = falso;
}
else // o nascer do sol vem depois do pôr do sol (em fusos horários opostos)
{
se (
(
dateInput.after(dataSunrise)
dateInput.equals(dataSunrise)
)
||// use OR em vez de AND
dateInput.before(dataPôr do sol)
)
bDaytime = verdadeiro;
outro
bDaytime = falso;
}
}
else if (bSunUpAllDay) // o sol nasce o dia todo
bDaytime = verdadeiro;
else if (bSunDownAllDay) // o sol se põe o dia todo
bDaytime = falso;
else if (bSunriseToday) // nascer do sol, mas sem pôr do sol
{
if (dataInput.before(dataSunrise))
bDaytime = falso;
outro
bDaytime = verdadeiro;
}
else if (bSunsetToday) // pôr do sol, mas sem nascer do sol
{
if (dataInput.before(dataPôr do sol))
bDaytime = verdadeiro;
outro
bDaytime = falso;
}
else bDaytime = false; // isso nunca deve ser executado
return(bDaytime);
}
} //fim da aula
/*------------------------------------------------ --------------------------
*fim da aula
*------------------------------------------------ - -------------------------*/