Ermitteln Sie die lokalen Sonnenauf- und -untergangszeiten basierend auf dem Breiten- und Längengrad sowie dem aktuellen Datum. Mithilfe einer leistungsstarken Google-Suche konnte ich schnell eine von einem Ausländer geschriebene Java-Klasse finden.
Posten Sie den Code direkt hier:
Kopieren Sie den Codecode wie folgt:
/************************************************ * ******************************
*
*SunriseSunset.java
*
************************************************** * *******************************
*
* Java-Klasse: SunriseSunset
*
*Diese Java-Klasse ist Teil einer Sammlung von Klassen, die für entwickelt wurden
*Lesen und Verarbeiten der gesammelten ozeanografischen und meteorologischen Daten
*seit 1970 durch Umweltbojen und Stationen Dies ist ein Datensatz
*verwaltet vom National Oceanographic Data Center und ist öffentlich
*verfügbar. Diese Java-Klassen wurden für die US-Umweltbehörde geschrieben
*Das National Exposure Research Laboratory der Protection Agency steht unter Vertrag
*Nr. GS-10F-0073K mit Neptune and Company aus Los Alamos, New Mexico.
*
*Zweck:
*
* Diese Java-Klasse führt Berechnungen durch, um die Zeit zu bestimmen
*Sonnenaufgang und Sonnenuntergang mit Breitengrad, Längengrad und Datum.
*
*Eingaben:
*
* Breitengrad, Längengrad, Datum/Uhrzeit und Zeitzone.
*
*Ausgänge:
*
* Ortszeit von Sonnenaufgang und Sonnenuntergang, wie von der berechnet
* Programm.
*Wenn kein Sonnenaufgang oder Sonnenuntergang stattfindet oder die Sonne den ganzen Tag scheint
* oder den ganzen Tag heruntergefahren werden, werden entsprechende boolesche Werte gesetzt.
*Es wird ein boolescher Wert bereitgestellt, um zu ermitteln, ob die angegebene Zeit tagsüber liegt.
*
*Auf die oben genannten Werte kann mit den folgenden Methoden zugegriffen werden:
*
*DategetSunrise() gibt Datum/Uhrzeit des Sonnenaufgangs zurück
*DategetSunset() gibt Datum/Uhrzeit des Sonnenuntergangs zurück
*booleanisSunrise() gibt true zurück, wenn es einen Sonnenaufgang gab, andernfalls false
*booleanisSunset() gibt true zurück, wenn es einen Sonnenuntergang gab, andernfalls false
*booleanisSunUp() gibt true zurück, wenn die Sonne den ganzen Tag scheint, andernfalls false
*booleanisSunDown() gibt „true“ zurück, wenn die Sonne den ganzen Tag untergeht, andernfalls „false“.
*booleanisDaytime() gibt true zurück, wenn zu diesem Zeitpunkt die Sonne scheint
*angegeben, sonst falsch
*
* Erforderliche Klassen aus der Java-Bibliothek:
*
* java.util.Date
*java.text.SimpleDateFormat
*java.text.ParseException;
* java.math.BigDecimal;
*
* Paket, zu dem diese Klasse gehört:
*
*Standard
*
* Bekannte Einschränkungen:
*
*Es wird davon ausgegangen, dass die bereitgestellten Daten innerhalb gültiger Bereiche liegen
*(d. h. Breitengrad zwischen -90 und +90, Längengrad zwischen 0 und 360,
*ein gültiges Datum und eine Zeitzone zwischen -14 und +14.
*
*Kompatibilität:
*
*Java 1.1.8
*
* Referenzen:
*
*Die in diesem Programm verwendeten mathematischen Algorithmen sind strukturiert
*nach denen, die Roger Sinnott in seinem BASIC-Programm entwickelt hat,
*SUNUP.BAS, veröffentlicht in der Zeitschrift Sky & Telescope:
*Sinnott, Roger W. „Sonnenaufgang und Sonnenuntergang: Eine Herausforderung“
*Sky & Telescope, August 1994, S. 84-85
*
*Das Folgende ist ein Querindex der in SUNUP.BAS verwendeten Variablen.
*Eine einzelne Definition aus mehrfacher Wiederverwendung von Variablennamen in
*SUNUP.BAS wurde in diesem Programm mit verschiedenen Definitionen geklärt.
*
*SUNUP.BASdiese Klasse
*
*AdfA
*A(2)dfAA1, dfAA2
*A0dfA0
*A2dfA2
*A5dfA5
*AZNicht verwendet
*CdfCosLat
*C0dfC0
*DiDay
*D(2)dfDD1, dfDD2
*D0dfD0
*D1dfD1
*D2dfD2
*D5dfD5
*D7Nicht verwendet
*DAdfDA
*DDdfDD
*GbGregorian, dfGG
*HdfTimeZone
*H0dfH0
*H1dfH1
*H2dfH2
*H3dfHourRise, dfHourSet
*H7Nicht verwendet
*JdfJ
*J3dfJ3
*K1dfK1
*LdfLL
*L0dfL0
*L2dfL2
*L5dfLon
*MiMonat
*M3dfMinRise, dfMinSet
*N7Nicht verwendet
*PDFP
*SiSign, dfSinLat, dfSS
*TdfT
*T0dfT0
*T3nicht verwendet
*TTdfTT
*UdfUU
*VdfVV
*V0dfV0
*V1dfV1
*V2dfV2
*WdfWW
*YiJahr
*ZdfZenith
*Z0dfTimeZone
*
*
* Autor/Firma:
*
* JDT: John Tauxe, Neptune and Company
*JMG: Jo Marie Green
*
* Änderungsprotokoll:
*
*Datum der Beschreibung der Änderung
*_________ _____ _______________________________________________
* 5. Jan. 01 0.006 JDTExposed aus ssapp.java v. 0.005.
*11 Jan 01 0.007 JDTKleinere Änderungen an Kommentaren basierend auf
* Material von Sinnott, 1994.
* 7. Februar 01 0,008 JDTFixed rückwärts Zeitzone Das ist der Standard
* Die lokale Zeitzone wird in Stunden östlich von angegeben
* Greenwich, sodass EST beispielsweise -5 wäre.
* Aus irgendeinem Grund macht SUNUP.BAS dies rückwärts
* (wahrscheinlich eine amerikanisch-zentrierte Perspektive) und
* SunriseSunset hat diese Konvention übernommen.
* Das Vorzeichen in der Mathematik wird also geändert.
* 7. Feb. 01 0,009 JDTNun, das hat die Azimutberechnung durcheinander gebracht ...
* Die Azimutberechnungen wurden entfernt.
*14.02.01 0,010 JDTMöglichkeit hinzugefügt, eine Zeit (HH:mm) in zu akzeptieren
* dateInput und entscheiden, ob es sich bei dieser Zeit um den Tag handelt
* oder nachts.
*27.02.01 0.011 JDTZugriffsmethoden anstelle von public hinzugefügt
* Variablen, um Ergebnisse zu erhalten.
*28.02.01 0.012 JDTListe der importierten Klassen bereinigt.
*28. März 01 1.10 JDTFinal-Version zu Lieferung 1b.
* 4. Apr. 01 1.11 JDTMoved-Logik, die .isDaytime unterstützt, in die Methode.
* Berechnungen aus dem Konstruktor verschoben.
* 01.05.01 1.12 JMG „GMT“-Bezeichnung und Testlinien hinzugefügt.
* 16. Mai 01 1.13 JDT setLenient( false ) und setTimeZone( tz ) hinzugefügt
* zu dfmtDay, dfmtMonth und dfmtYear in
*Berechnungen durchführen.
* 27. Juni 01 1.14 JDTDie Abhängigkeit von StationConstants (GMT) wurde entfernt.
*13. Aug. 01 1.20 JDTFinal-Version zu Lieferung 1c.
* 6. September 01 1.21 JDTTgründliche Code- und Kommentarüberprüfung.
*21.09.01 1.30 JDTFinalversion zu Lieferung 2.
*17. Dez. 01 1.40 JDTVersion, die der endgültigen Lieferung beiliegt.
*
*------------------------------------------------ - -----------*/
//Erforderliche Klassen und Pakete importieren
import java.util.Date;
import java.text.SimpleDateFormat;
import java.text.ParseException;
import java.math.BigDecimal;
import java.util.TimeZone;
/************************************************ * ******************************
*class:SunriseSunset-Klasse
************************************************** * *******************************
*
* Diese Java-Klasse führt Berechnungen durch, um die Zeit zu bestimmen
*Sonnenaufgang und Sonnenuntergang mit Breitengrad, Längengrad und Datum.
*
*Es wird davon ausgegangen, dass die bereitgestellten Daten innerhalb gültiger Bereiche liegen
*(d. h. Breitengrad zwischen -90 und +90, Längengrad zwischen 0 und 360,
*ein gültiges Datum und eine Zeitzone zwischen -14 und +14.
*
*------------------------------------------------ - -----------*/
öffentliche KlasseSunriseSunset
{
// Variablen deklarieren und initialisieren
private doubledfLat;// Breitengrad vom Benutzer
private doubledfLon;// Breitengrad vom Benutzer
private DatedateInput; // Datum/Uhrzeit vom Benutzer
private doubledfTimeZone;// Zeitzone vom Benutzer
private DatedateSunrise;// Datum und Uhrzeit des Sonnenaufgangs
private DatedateSunset;//Datum und Uhrzeit des Sonnenuntergangs
private booleanbSunriseToday = false;// Flag für Sonnenaufgang an diesem Datum
private booleanbSunsetToday = false;// Flag für Sonnenuntergang an diesem Datum
private booleanbSunUpAllDay = false;// Flag für Sonnenaufgang den ganzen Tag
private booleanbSunDownAllDay = false;// Flag für Sonnenuntergang den ganzen Tag
private booleanbDaytime = false; // Flag für Tageszeit, gegeben
// Stunde und Minute in dateInput
private booleanbSunrise = false; // Sonnenaufgang während der Stunde überprüft
private booleanbSunset = false; // Sonnenuntergang während der Stunde überprüft
private booleanbGregorian = false;// Flag für gregorianischen Kalender
privater intiJulian;//Julianischer Tag
privateintiYear;// Jahr des interessierenden Datums
privateintiMonth;// Monat des interessierenden Datums
privateintiDay;// Tag des Datums von Interesse
privateintiCount;// ein einfacher Zähler
privateintiSign;// SUNUP.BAS: S
private doubledfHourRise, dfHourSet;// Stunde des Ereignisses: SUNUP.BAS H3
private doubledfMinRise, dfMinSet;// Minute des Ereignisses: SUNUP.BAS M3
privatedoubledfSinLat, dfCosLat;// Sinus und Kosinus des Breitengrads
privatedoubledfZenith;// SUNUP.BAS Z: Zenith
privateSimpleDateFormat dfmtDate;// Formatierung nur für das Datum
privateSimpleDateFormat dfmtDateTime;// Formatierung für Datum und Uhrzeit
privateSimpleDateFormat dfmtYear;// Formatierung für Jahr
privateSimpleDateFormat dfmtMonth;// Formatierung für Monat
privateSimpleDateFormat dfmtDay;// Formatierung für Tag
// Viele Variablen in SUNUP.BAS haben undokumentierte Bedeutungen,
// und so werden eher direkt übersetzt, um Verwirrung zu vermeiden:
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
private TimeZone tz = TimeZone.getTimeZone( "GMT" );
/************************************************ * ******************************
*Methode:SonnenaufgangSonnenuntergang
************************************************** * *******************************
*
*Konstruktor für die SunriseSunset-Klasse.
*
*------------------------------------------------ - -----------*/
SonnenaufgangSonnenuntergang(
double dfLatIn,//latitude
double dfLonIn,// Längengrad
Datum dateInputIn,// Datum
double dfTimeZoneIn// Zeitzone
)
{
// Als Argumente bereitgestellte Werte in lokale Variablen kopieren.
dfLat = dfLatIn;
dfLon = dfLonIn;
dateInput = dateInputIn;
dfTimeZone = dfTimeZoneIn;
// Rufen Sie die Methode auf, um die Berechnungen durchzuführen.
doCalculations();
} // Ende des Klassenkonstruktors
/************************************************ * ******************************
*Methode:Berechnungen durchführen
************************************************** * *******************************
*
*Methode zur Durchführung der in SUNUP.BAS durchgeführten Berechnungen.
*
*------------------------------------------------ - -----------*/
private void doCalculations()
{
versuchen
{
// Tag, Monat und Jahr aus dem angegebenen Datum aufschlüsseln.
// (Dies ist für die mathematischen Algorithmen notwendig.)
dfmtYear = new SimpleDateFormat( "yyyy" );
dfmtYear.setLenient( false );
dfmtYear.setTimeZone(tz);
dfmtMonth = new SimpleDateFormat( "M" );
dfmtMonth.setLenient( false );
dfmtMonth.setTimeZone(tz);
dfmtDay = new SimpleDateFormat( "d" );
dfmtDay.setLenient( false );
dfmtDay.setTimeZone(tz);
iYear = Integer.parseInt( dfmtYear.format( dateInput ) );
iMonth = Integer.parseInt( dfmtMonth.format( dateInput ) );
iDay = Integer.parseInt( dfmtDay.format( dateInput ) );
// Zeitzonenstunden in Dezimaltage umwandeln (SUNUP.BAS Zeile 50)
dfTimeZone = dfTimeZone / 24,0;
// HINWEIS: (7. Februar 2001) Hier ist ein nicht standardmäßiger Teil von SUNUP.BAS:
// Es (und dieser Algorithmus) geht davon aus, dass die Zeitzone ist
// positiver Westen, anstelle des standardmäßigen negativen Westens.
// Klassen, die SunriseSunset aufrufen, gehen davon aus
// Zeitzonen werden im negativen Westen angegeben, also hier die
// Vorzeichen wird geändert, damit der SUNUP-Algorithmus funktioniert:
dfTimeZone = -dfTimeZone;
// Längengrad in Bruch umwandeln (SUNUP.BAS Zeile 50)
dfLon = dfLon / 360,0;
// Kalenderdatum in Julianisches Datum umwandeln:
// Überprüfen Sie, ob es nach 1583 ist: Gregorianischer Kalender
// Bei der Deklaration wird bGregorian mit „false“ initialisiert.
// ** Erwägen Sie die Erstellung einer separaten Klasse dieser Funktion **.
if( iYear >= 1583 ) bGregorian = true;
// SUNUP.BAS 1210
dfJ = -Math.floor( 7.0// SUNUP verwendete INT, nicht floor
* (Math.floor(
(iMonat+9,0)
/12.0
) + iJahr
) / 4.0
)
// SUNUP.BAS 1240 und 1250 für G = 0 hinzufügen
+ Math.floor( iMonth * 275,0 / 9,0 )
+ iDay
+1721027.0
+ iJahr * 367,0;
if(bGregorian)
{
// SUNUP.BAS 1230
if ( ( iMonth - 9.0 ) < 0.0 ) iSign = -1;
sonst iSign = 1;
dfA = Math.abs( iMonth - 9.0 );
// SUNUP.BAS 1240 und 1250
dfJ3 = -Math.floor(
(
Math.floor(
Math.floor( iYear
+ (doppeltes)iSign
* Math.floor( dfA / 7.0 )
)
/100,0
) + 1,0
) * 0,75
);
// dfJ wie in SUNUP.BAS 1240 und 1250 für G = 1 korrigieren
dfJ = dfJ + dfJ3 + 2,0;
}
// SUNUP.BAS 1290
iJulian = (int)dfJ - 1;
// SUNUP.BAS 60 und 70 (siehe auch Zeile 1290)
dfT = (double)iJulian - 2451545,0 + 0,5;
dfTT = dfT / 36525,0 + 1,0 // Jahrhunderte seit 1900
// Lokale Sternzeit bei 0h in der Zonenzeit berechnen
// SUNUP.BAS 410 bis 460
dfT0 = (dfT * 8640184,813 / 36525,0
+24110.5
+dfTimeZone*86636.6
+dfLon*86400.0
)
/86400.0;
dfT0 = dfT0 - Math.floor( dfT0 ); // HINWEIS: SUNUP.BAS verwendet INT()
dfT0 = dfT0 * 2.0 * Math.PI;
// SUNUP.BAS 90
dfT = dfT + dfTimeZone;
// SUNUP.BAS 110: Sonnenposition abrufen
for( iCount=0; iCount<=1; iCount++ )// Nur zweimal durchlaufen
{
// Rektaszension und Deklination der Sonne berechnen
// am Anfang und am Ende eines jeden Tages.
// SUNUP.BAS 910 - 1160: Grundlegende Argumente
// von van Flandern und Pulkkinen, 1979
// lokale temporäre Doubles für Berechnungen deklarieren
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 * 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;
// Berechnen Sie Suns RA und Dec; 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 ));
// Werte setzen und t erhöhen
if ( iCount == 0 )// SUNUP.BAS 125
{
dfAA1 = dfA5;
dfDD1 = dfD5;
}
sonst// SUNUP.BAS 145
{
dfAA2 = dfA5;
dfDD2 = dfD5;
}
dfT = dfT + 1,0; // SUNUP.BAS 130
}// Ende der Get Sun's Position for-Schleife
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
// Sonnenaufgangs- und Sonnenuntergangszeiten und andere Variablen initialisieren
// Std. und Min. werden auf unmögliche Zeiten eingestellt, um Fehler offensichtlich zu machen
dfHourRise = 99,0;
dfMinRise = 99,0;
dfHourSet = 99,0;
dfMinSet = 99,0;
dfV0 = 0.0;// Initialisierung impliziert durch Abwesenheit in SUNUP.BAS
dfV2 = 0.0;// Initialisierung impliziert durch Abwesenheit in SUNUP.BAS
// Testen Sie jede Stunde, ob die Sonne den Horizont überquert
// und in welche Richtung es geht.
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 = (double)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
// Stundenwinkel zur halben Stunde
dfH1 = ( dfH2 + dfH0 ) / 2.0;// SUNUP.BAS 520
// Deklination zur halben Stunde
dfD1 = ( dfD2 + dfD0 ) / 2.0;// SUNUP.BAS 530
// Wert von dfV0 nur setzen, wenn dies die erste Stunde ist,
// andernfalls wird es auf den letzten dfV2 (SUNUP.BAS 250) gesetzt
if (iCount == 0)// SUNUP.BAS 550
{
dfV0 = dfSinLat * Math.sin( dfD0 )
+ dfCosLat * Math.cos( dfD0 ) * Math.cos( dfH0 )
- Math.cos( dfZenith );// SUNUP.BAS 560
}
anders
dfV0 = dfV2;// Das heißt, dfV2 aus der vorherigen Stunde.
dfV2 = dfSinLat * Math.sin( dfD2 )
+ dfCosLat * Math.cos( dfD2 ) * Math.cos( dfH2 )
- Math.cos( dfZenith );// SUNUP.BAS 570
// wenn dfV0 und dfV2 das gleiche Vorzeichen haben, dann mit der nächsten Stunde fortfahren
Wenn (
( dfV0 >= 0.0 && dfV2 >= 0.0 )// beide sind positiv
||// oder
( dfV0 < 0.0 && dfV2 < 0.0 ) // beide sind negativ
)
{
// Iteration unterbrechen und nächste Stunde mit dem Test fortfahren
dfA0 = dfA2;// SUNUP.BAS 250
dfD0 = dfD2;// SUNUP.BAS 250
fortfahren;// 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
if (tempD < 0,0)
{
// Iteration unterbrechen und nächste Stunde mit dem Test fortfahren
dfA0 = dfA2;// SUNUP.BAS 250
dfD0 = dfD2;// SUNUP.BAS 250
fortfahren;// SUNUP.BAS 610
}
tempD = Math.sqrt( tempD );// SUNUP.BAS 620
// Bestimmen Sie das Auftreten von Sonnenaufgang oder Sonnenuntergang.
// Flags zur Identifizierung des Vorkommens an diesem Tag sind
// bSunriseToday und bSunsetToday und werden mit false initialisiert.
// Diese werden nur dann auf „true“ gesetzt, wenn Sonnenaufgang oder Sonnenuntergang auftritt
// zu keinem Zeitpunkt in der stündlichen Schleife setzen.
// Flags zur Identifizierung des Vorkommens während dieser Stunde:
bSunrise = false; // vor dem Test zurücksetzen
bSunset = false; // vor dem Test zurücksetzen
if ( dfV0 < 0.0 && dfV2 > 0.0 )// Sonnenaufgang findet diese Stunde statt
{
bSunrise = true; // SUNUP.BAS 640
bSunriseToday = true; // Sonnenaufgang ist heute aufgetreten
}
if ( dfV0 > 0.0 && dfV2 < 0.0 )// Der Sonnenuntergang findet zu dieser Stunde statt
{
bSunset = true; // SUNUP.BAS 660
bSunsetToday = true;// Der Sonnenuntergang ist heute eingetreten
}
tempE = (tempD - tempB) / (2,0 * tempA);
if (tempE > 1.0 || tempE < 0.0 )// SUNUP.BAS 670, 680
tempE = ( -tempD - tempB ) / ( 2,0 * tempA );
// Werte für Stunde und Minute des Sonnenuntergangs oder Sonnenaufgangs festlegen
// nur wenn Sonnenaufgang/-untergang zu dieser Stunde stattgefunden hat.
if(bSonnenaufgang)
{
dfHourRise = Math.floor( dfC0 + tempE + 1.0/120.0 );
dfMinRise = Math.floor(
(dfC0 + tempE + 1,0/120,0
- dfHourRise
)
* 60,0
);
}
if(bSonnenuntergang)
{
dfHourSet = Math.floor( dfC0 + tempE + 1.0/120.0 );
dfMinSet = Math.floor(
(dfC0 + tempE + 1,0/120,0
- dfHourSet
)
* 60,0
);
}
// Einstellungen der Variablen für die nächste Schleife ändern
dfA0 = dfA2;// SUNUP.BAS 250
dfD0 = dfD2;// SUNUP.BAS 250
}//Ende der Schleife jede Stunde auf ein Ereignis testen
// Nachdem alle Stunden überprüft wurden, Flags setzen, wenn kein Anstieg oder Untergang erfolgt
// bSunUpAllDay und bSundownAllDay werden als false initialisiert
if ( !bSunriseToday && !bSunsetToday )
{
wenn (dfV2 < 0,0)
bSunDownAllDay = true;
anders
bSunUpAllDay = true;
}
// dateSunrise mit Daten laden
dfmtDateTime = new SimpleDateFormat( "d M yyyy HH:mm z" );
if(bSunriseToday)
{
dateSunrise = dfmtDateTime.parse(iDay
+ " " + iMonat
+ " " + iJahr
+ " " + (int)dfHourRise
+ ":" + (int)dfMinRise
+ „GMT“ );
}
// dateSunset mit Daten laden
if(bSunsetToday)
{
dateSunset = dfmtDateTime.parse(iDay
+ " " + iMonat
+ " " + iJahr
+ " " + (int)dfHourSet
+ ":" + (int)dfMinSet
+ „GMT“ );
}
} // Ende des Versuchs
// Fehler abfangen
Catch(ParseException e)
{
System.out.println( "/nDatum kann nicht analysiert werden" );
System.out.println(e);
System.exit(1);
} // Ende des Fangs
}
/************************************************ * ******************************
*method:getSunrise()
************************************************** * *******************************
*
* Ruft das Datum und die Uhrzeit des Sonnenaufgangs ab. Wenn es keinen Sonnenaufgang gibt, wird null zurückgegeben.
*
*Mitglied der SunriseSunset-Klasse
*
*------------------------------------------------ - ------------- */
öffentliches Datum getSunrise()
{
if(bSunriseToday)
return(dateSunrise);
anders
return(null);
}
/************************************************ * ******************************
*method:getSunset()
************************************************** * *******************************
*
* Ruft das Datum und die Uhrzeit des Sonnenuntergangs ab. Wenn es keinen Sonnenuntergang gibt, wird null zurückgegeben.
*
*Mitglied der SunriseSunset-Klasse
*
*------------------------------------------------ - ------------- */
öffentliches Datum getSunset()
{
if(bSunsetToday)
return(dateSunset);
anders
return(null);
}
/************************************************ * ******************************
*method:isSunrise()
************************************************** * *******************************
*
* Gibt einen booleschen Wert zurück, der angibt, ob es einen Sonnenaufgang gab.
*
*Mitglied der SunriseSunset-Klasse
*
*------------------------------------------------ - ------------- */
öffentlicher boolescher Wert isSunrise()
{
return( bSunriseToday );
}
/************************************************ * ******************************
*method:isSunset()
************************************************** * *******************************
*
* Gibt einen booleschen Wert zurück, der angibt, ob es einen Sonnenuntergang gab.
*
*Mitglied der SunriseSunset-Klasse
*
*------------------------------------------------ - ------------- */
öffentlicher boolescher Wert isSunset()
{
return( bSunsetToday );
}
/************************************************ * ******************************
*method:isSunUp()
************************************************** * *******************************
*
* Gibt einen booleschen Wert zurück, der angibt, ob die Sonne den ganzen Tag scheint.
*
*Mitglied der SunriseSunset-Klasse
*
*------------------------------------------------ - ------------- */
öffentlicher boolescher Wert isSunUp()
{
return( bSunUpAllDay );
}
/************************************************ * ******************************
*method:isSunDown()
************************************************** * *******************************
*
* Gibt einen booleschen Wert zurück, der angibt, ob die Sonne den ganzen Tag untergeht.
*
*Mitglied der SunriseSunset-Klasse
*
*------------------------------------------------ - ------------- */
öffentlicher boolescher Wert isSunDown()
{
return( bSunDownAllDay );
}
/************************************************ * ******************************
*method:isDaytime()
************************************************** * *******************************
*
* Gibt einen booleschen Wert zurück, der angibt, ob zu der in angegebenen Stunde Tag ist
*das Date-Objekt, das bei der Erstellung an SunriseSunset übergeben wird.
*
*Mitglied der SunriseSunset-Klasse
*
*------------------------------------------------ - ------------- */
öffentlicher boolescher Wert isDaytime()
{
// Bestimmen Sie, ob es Tag ist (bei Sonnenaufgang oder später)
//oder nachts (bei Sonnenuntergang oder später) am gewünschten Ort
//aber ausgedrückt in der gewünschten Zeitzone.
if ( bSunriseToday && bSunsetToday ) // Sonnenaufgang und Sonnenuntergang
{
if ( dateSunrise.before( dateSunset ) )// Sonnenaufgang < Sonnenuntergang
{
Wenn (
(
dateInput.after(dateSunrise)
dateInput.equals(dateSunrise)
)
&&
dateInput.before(dateSunset)
)
bDaytime = true;
anders
bDaytime = false;
}
sonst // Sonnenaufgang kommt nach Sonnenuntergang (in entgegengesetzten Zeitzonen)
{
Wenn (
(
dateInput.after(dateSunrise)
dateInput.equals(dateSunrise)
)
||// Verwenden Sie OR statt AND
dateInput.before(dateSunset)
)
bDaytime = true;
anders
bDaytime = false;
}
}
else if ( bSunUpAllDay ) // Die Sonne scheint den ganzen Tag
bDaytime = true;
else if ( bSunDownAllDay )// Die Sonne scheint den ganzen Tag unter
bDaytime = false;
else if ( bSunriseToday ) // Sonnenaufgang, aber kein Sonnenuntergang
{
if ( dateInput.before( dateSunrise ) )
bDaytime = false;
anders
bDaytime = true;
}
else if ( bSunsetToday ) // Sonnenuntergang, aber kein Sonnenaufgang
{
if ( dateInput.before( dateSunset ) )
bDaytime = true;
anders
bDaytime = false;
}
else bDaytime = false; // dies sollte niemals ausgeführt werden
return(bDaytime);
}
} // Ende der Klasse
/*------------------------------------------------ --------------------------
*Ende des Unterrichts
*------------------------------------------------ - -----------*/