AbsoluteDate (OREKIT 12.0.1 API)

java.lang.Object
- org.orekit.time.AbsoluteDate

All Implemented Interfaces:

Serializable, Comparable<AbsoluteDate>, TimeShiftable<AbsoluteDate>, TimeStamped
```
public class AbsoluteDate
extends Object
implements TimeStamped, TimeShiftable<AbsoluteDate>, Comparable<AbsoluteDate>, Serializable
```
这个类表示时间中的特定时刻。
该类的实例被认为是绝对的，因为每个实例代表某个事件的发生，并且可以与其他实例进行比较或定位在任何时间尺度中。换句话说，事件相对于两个不同时间尺度（例如TAI和UTC）的不同位置只是与单个对象相关的不同视角。只需要一个AbsoluteDate实例，通过在调用特定方法时将时间尺度作为参数指定，可以从这个单一实例中获得两种表示。

由于实例不绑定到特定的时间尺度，所有与日期在某个时间尺度内的位置相关的方法都需要提供时间尺度作为参数。因此，可以在一个时间尺度中定义日期并在另一个时间尺度中使用它。一个这样的用例示例是从UTC文件中读取日期并将其写入TAI文件。可以按照以下方式执行：
```
   DateTimeComponents utcComponents = readNextDate();
   AbsoluteDate date = new AbsoluteDate(utcComponents, TimeScalesFactory.getUTC());
   writeNextDate(date.getComponents(TimeScalesFactory.getTAI()));
 
```
有两种互补的视图：
- 位置视图（主要用于输入/输出或转换）
  
  位置表示一个事件相对于时间尺度的坐标。相关方法有AbsoluteDate(DateComponents, TimeComponents, TimeScale)、AbsoluteDate(int, int, int, int, int, double, TimeScale)、AbsoluteDate(int, int, int, TimeScale)、AbsoluteDate(Date, TimeScale)、parseCCSDSCalendarSegmentedTimeCode(byte, byte[])、toDate(TimeScale)、toString(timeScale)、toString()和timeScalesOffset(TimeScale, TimeScale)。
- 偏移视图（主要用于物理计算）
  
  偏移表示两个事件（类的两个实例）之间的时间流逝或持续时间。它们以秒为单位计数，是连续的，并且可以使用一个几乎完美的秒表来测量。相关方法有AbsoluteDate(AbsoluteDate, double)、parseCCSDSUnsegmentedTimeCode(byte, byte, byte[], AbsoluteDate)、parseCCSDSDaySegmentedTimeCode(byte, byte[], DateComponents)、durationFrom(AbsoluteDate)、compareTo(AbsoluteDate)、equals(Object)和hashCode()。
已经定义了一些在空间系统中常用的参考时期。这些时期可以用作偏移计算的基础。支持的时期有：JULIAN_EPOCH、MODIFIED_JULIAN_EPOCH、FIFTIES_EPOCH、CCSDS_EPOCH、GALILEO_EPOCH、GPS_EPOCH、QZSS_EPOCH、J2000_EPOCH、JAVA_EPOCH。还有两个工厂方法createJulianEpoch(double)和createBesselianEpoch(double)，可用于计算其他参考时期，如J1900.0或B1950.0。除了这些参考时期外，还为方便起见定义了两个常量：PAST_INFINITY和FUTURE_INFINITY，可以在日期尚未初始化时用作虚拟日期，或用于初始化搜索最小或最大日期的循环。

AbsoluteDate类的实例保证是不可变的。
Author:

Luc Maisonobe, Evan Ward

See Also:

TimeScale, TimeStamped, ChronologicalComparator, Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static AbsoluteDate`	`ARBITRARY_EPOCH` 一个任意的有限日期。
`static AbsoluteDate`	`BEIDOU_EPOCH` 北斗周的参考时期：2006-01-01T00:00:00 UTC。
`static AbsoluteDate`	`CCSDS_EPOCH` CCSDS时间代码格式（CCSDS 301.0-B-4）的参考时期：1958-01-01T00:00:00 国际原子时（非UTC）。
`static AbsoluteDate`	`FIFTIES_EPOCH` 1950年日期的参考时期：1950-01-01T00:00:00 地球时间。
`static AbsoluteDate`	`FUTURE_INFINITY` 未来方向上的无限虚拟日期。
`static AbsoluteDate`	`GALILEO_EPOCH` 伽利略系统时间的参考时期：1999-08-22T00:00:00 GST。
`static AbsoluteDate`	`GLONASS_EPOCH` GLONASS四年间隔编号的参考时期：1996-01-01T00:00:00 GLONASS时间。
`static AbsoluteDate`	`GPS_EPOCH` GPS周的参考时期：1980-01-06T00:00:00 GPS时间。
`static AbsoluteDate`	`IRNSS_EPOCH` IRNSS周的参考时期：1999-08-22T00:00:00 IRNSS时间。
`static AbsoluteDate`	`J2000_EPOCH` J2000.0参考时期：2000-01-01T12:00:00 地球时间（非UTC）。
`static AbsoluteDate`	`JAVA_EPOCH` Java参考时期：1970-01-01T00:00:00 世界时。
`static AbsoluteDate`	`JULIAN_EPOCH` 儒略日期的参考时期：-4712-01-01T12:00:00 地球时间。
`static AbsoluteDate`	`MODIFIED_JULIAN_EPOCH` 修正儒略日期的参考时期：1858-11-17T00:00:00 地球时间。
`static AbsoluteDate`	`PAST_INFINITY` 过去方向上的无限虚拟日期。
`static AbsoluteDate`	`QZSS_EPOCH` QZSS周的参考时期：1980-01-06T00:00:00 QZSS时间。

Constructor Summary

Constructors
Constructor and Description
`AbsoluteDate()` 使用默认值（J2000_EPOCH）创建一个实例。
`AbsoluteDate(AbsoluteDate since, double elapsedDuration)` 从另一个时刻的经过时间构建一个实例。
`AbsoluteDate(AbsoluteDate reference, double apparentOffset, TimeScale timeScale)` 根据相对于另一个时刻的表观时钟偏移构建一个实例（在特定时间尺度的视角中）。
`AbsoluteDate(DateComponents date, TimeComponents time, TimeScale timeScale)` 根据时间尺度中的位置构建一个实例。
`AbsoluteDate(DateComponents date, TimeScale timeScale)` 根据时间尺度中的位置构建一个实例。
`AbsoluteDate(DateTimeComponents location, TimeScale timeScale)` 根据时间尺度中的位置构建一个实例。
`AbsoluteDate(Date location, TimeScale timeScale)` 根据时间尺度中的位置构建一个实例。
`AbsoluteDate(Instant instant, TimeScale timeScale)` 根据时间尺度中的位置（从字符串解析）构建一个实例。
`AbsoluteDate(int year, int month, int day, int hour, int minute, double second, TimeScale timeScale)` 根据时间尺度中的位置构建一个实例。
`AbsoluteDate(int year, int month, int day, TimeScale timeScale)` 根据时间尺度中的位置构建一个实例。
`AbsoluteDate(int year, Month month, int day, int hour, int minute, double second, TimeScale timeScale)` 根据时间尺度中的位置构建一个实例。
`AbsoluteDate(int year, Month month, int day, TimeScale timeScale)` 根据时间尺度中的位置构建一个实例。
`AbsoluteDate(String location, TimeScale timeScale)` 根据时间尺度中的位置（从字符串解析）构建一个实例。

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`compareTo(AbsoluteDate date)` 将实例与另一个日期进行比较。
`static AbsoluteDate`	`createBesselianEpoch(double besselianEpoch)` 构建对应于Besselian Epoch（BE）的实例。
`static AbsoluteDate`	`createJDDate(int jd, double secondsSinceNoon, TimeScale timeScale)` 构建对应于儒略日日期的实例。
`static AbsoluteDate`	`createJulianEpoch(double julianEpoch)` 构建对应于儒略纪元（JE）的实例。
`static AbsoluteDate`	`createMJDDate(int mjd, double secondsInDay, TimeScale timeScale)` 构建对应于修正儒略日日期的实例。
`double`	`durationFrom(AbsoluteDate instant)` 计算两个时刻之间的物理经过时间。
`boolean`	`equals(Object date)` 检查实例是否表示与另一个实例相同的时间。
`DateTimeComponents`	`getComponents(int minutesFromUTC)` 将实例拆分为本地时间的日期/时间组件。
`DateTimeComponents`	`getComponents(int minutesFromUTC, TimeScale utc)` 将实例拆分为本地时间的日期/时间组件。
`DateTimeComponents`	`getComponents(TimeScale timeScale)` 将实例拆分为日期/时间组件。
`DateTimeComponents`	`getComponents(TimeZone timeZone)` 将实例拆分为时区的日期/时间组件。
`DateTimeComponents`	`getComponents(TimeZone timeZone, TimeScale utc)` 将实例拆分为时区的日期/时间组件。
`AbsoluteDate`	`getDate()` 获取日期。
`int`	`hashCode()` 获取此日期的哈希码。
`boolean`	`isAfter(TimeStamped other)` 检查实例是否表示晚于另一个时间。
`boolean`	`isAfterOrEqualTo(TimeStamped other)` 检查实例是否表示晚于或等于另一个时间。
`boolean`	`isBefore(TimeStamped other)` 检查实例是否表示早于另一个时间。
`boolean`	`isBeforeOrEqualTo(TimeStamped other)` 检查实例是否表示早于或等于另一个时间。
`boolean`	`isBetween(TimeStamped boundary, TimeStamped otherBoundary)` 检查实例是否表示严格介于两个表示时间跨度边界的其他时间之间。
`boolean`	`isBetweenOrEqualTo(TimeStamped boundary, TimeStamped otherBoundary)` 检查实例是否表示介于两个表示时间跨度边界的其他时间之间，或等于其中一个。
`boolean`	`isCloseTo(TimeStamped other, double tolerance)` 检查实例时间是否接近另一个时间。
`boolean`	`isEqualTo(TimeStamped other)` 检查实例是否表示与另一个时间相同。
`double`	`offsetFrom(AbsoluteDate instant, TimeScale timeScale)` 计算两个瞬时之间的表观时钟偏移量，从特定的`时间标度`的视角。
`static AbsoluteDate`	`parseCCSDSCalendarSegmentedTimeCode(byte preambleField, byte[] timeField)` 从CCSDS日历分段时间代码（CCS）构建实例。
`static AbsoluteDate`	`parseCCSDSCalendarSegmentedTimeCode(byte preambleField, byte[] timeField, TimeScale utc)` 从CCSDS日历分段时间代码（CCS）构建实例。
`static AbsoluteDate`	`parseCCSDSDaySegmentedTimeCode(byte preambleField, byte[] timeField, DateComponents agencyDefinedEpoch)` 从CCSDS日分段时间代码（CDS）构建实例。
`static AbsoluteDate`	`parseCCSDSDaySegmentedTimeCode(byte preambleField, byte[] timeField, DateComponents agencyDefinedEpoch, TimeScale utc)` 从CCSDS日分段时间代码（CDS）构建实例。
`static AbsoluteDate`	`parseCCSDSUnsegmentedTimeCode(byte preambleField1, byte preambleField2, byte[] timeField, AbsoluteDate agencyDefinedEpoch)` 从CCSDS非分段时间代码（CUC）构建实例。
`static AbsoluteDate`	`parseCCSDSUnsegmentedTimeCode(byte preambleField1, byte preambleField2, byte[] timeField, AbsoluteDate agencyDefinedEpoch, AbsoluteDate ccsdsEpoch)` 从CCSDS非分段时间代码（CUC）构建实例。
`AbsoluteDate`	`shiftedBy(double dt)` 获取一个时间偏移的日期。
`double`	`timeScalesOffset(TimeScale scale1, TimeScale scale2)` 计算当前瞬时两个时间标度之间的偏移量。
`Date`	`toDate(TimeScale timeScale)` 将实例转换为Java `Date`。
`String`	`toString()` 获取实例位置的字符串表示，秒值精度最多为16位。
`String`	`toString(int minutesFromUTC)` 获取本地时间的实例位置的字符串表示。
`String`	`toString(int minutesFromUTC, TimeScale utc)` 获取本地时间的实例位置的字符串表示。
`String`	`toString(TimeScale timeScale)` 获取ISO-8601格式的实例位置的字符串表示，不包括UTC偏移，并且秒值精度最多为16位。
`String`	`toString(TimeZone timeZone)` 获取时区的实例位置的字符串表示。
`String`	`toString(TimeZone timeZone, TimeScale utc)` 获取时区的实例位置的字符串表示。
`String`	`toStringRfc3339(TimeScale utc)` 根据RFC 3339中的格式将给定日期表示为字符串。
`String`	`toStringWithoutUtcOffset(TimeScale timeScale, int fractionDigits)` 返回此日期时间的字符串表示，四舍五入到给定精度。

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.orekit.time.TimeStamped
durationFrom

- Field Detail
  - JULIAN_EPOCH
```
@DefaultDataContext
public static final AbsoluteDate JULIAN_EPOCH
```
    朱利安日期的参考时期：地球时-4712-01-01T12:00:00。
    java.util.Date和DateComponents类遵循天文约定，将年份0视为-1年和+1年之间，因此此参考日期位于-4712年而不是其他遵循不同约定的文档或程序中的-4713年（例如convcal实用程序）。
    
    此常量使用默认数据上下文。
    
    另请参阅:
    
    TimeScales.getJulianEpoch()
  - MODIFIED_JULIAN_EPOCH
```
@DefaultDataContext
public static final AbsoluteDate MODIFIED_JULIAN_EPOCH
```
    修改朱利安日期的参考时期：地球时1858-11-17T00:00:00。
    此常量使用默认数据上下文。
    
    另请参阅:
    
    TimeScales.getModifiedJulianEpoch()
  - FIFTIES_EPOCH
```
@DefaultDataContext
public static final AbsoluteDate FIFTIES_EPOCH
```
    1950年日期的参考时期：地球时1950-01-01T00:00:00。
    此常量使用默认数据上下文。
    
    另请参阅:
    
    TimeScales.getFiftiesEpoch()
  - CCSDS_EPOCH
```
@DefaultDataContext
public static final AbsoluteDate CCSDS_EPOCH
```
    CCSDS时间代码格式（CCSDS 301.0-B-4）的参考时期：国际原子时1958-01-01T00:00:00（非 UTC）。
    此常量使用默认数据上下文。
    
    另请参阅:
    
    TimeScales.getCcsdsEpoch()
  - GALILEO_EPOCH
```
@DefaultDataContext
public static final AbsoluteDate GALILEO_EPOCH
```
    伽利略系统时间的参考时期：GST1999-08-22T00:00:00。
    此常量使用默认数据上下文。
    
    另请参阅:
    
    TimeScales.getGalileoEpoch()
  - GPS_EPOCH
```
@DefaultDataContext
public static final AbsoluteDate GPS_EPOCH
```
    GPS周的参考时期：GPS时间1980-01-06T00:00:00。
    此常量使用默认数据上下文。
    
    另请参阅:
    
    TimeScales.getGpsEpoch()
  - QZSS_EPOCH
```
@DefaultDataContext
public static final AbsoluteDate QZSS_EPOCH
```
    QZSS周的参考时期：QZSS时间1980-01-06T00:00:00。
    此常量使用默认数据上下文。
    
    另请参阅:
    
    TimeScales.getQzssEpoch()
  - IRNSS_EPOCH
```
@DefaultDataContext
public static final AbsoluteDate IRNSS_EPOCH
```
    IRNSS周的参考时期：IRNSS时间1999-08-22T00:00:00。
    此常量使用默认数据上下文。
    
    另请参阅:
    
    TimeScales.getIrnssEpoch()
  - BEIDOU_EPOCH
```
@DefaultDataContext
public static final AbsoluteDate BEIDOU_EPOCH
```
    北斗周的参考时期：UTC2006-01-01T00:00:00。
    此常量使用默认数据上下文。
    
    另请参阅:
    
    TimeScales.getBeidouEpoch()
  - GLONASS_EPOCH
```
@DefaultDataContext
public static final AbsoluteDate GLONASS_EPOCH
```
    GLONASS四年间隔编号的参考时期：GLONASS时间1996-01-01T00:00:00。
    按照惯例，TGLONASS = UTC + 3小时。
    
    此常量使用默认数据上下文。
    
    另请参阅:
    
    TimeScales.getGlonassEpoch()
  - J2000_EPOCH
```
@DefaultDataContext
public static final AbsoluteDate J2000_EPOCH
```
    J2000.0参考时期：地球时2000-01-01T12:00:00（非 UTC）。
    此常量使用默认数据上下文。
    
    另请参阅:
    
    createJulianEpoch(double), createBesselianEpoch(double), TimeScales.getJ2000Epoch()
  - JAVA_EPOCH
```
@DefaultDataContext
public static final AbsoluteDate JAVA_EPOCH
```
    Java参考时期：协调世界时1970-01-01T00:00:00。
    在1968-02-01和1972-01-01之间，UTC-TAI = 4.213 170 0秒 +（MJD - 39 126）x 0.002 592秒。因为在1970-01-01时MJD = 40587，UTC-TAI = 8.000082秒
    
    此常量使用默认数据上下文。
    
    另请参阅:
    
    TimeScales.getJavaEpoch()
  - ARBITRARY_EPOCH
```
public static final AbsoluteDate ARBITRARY_EPOCH
```
    任意有限日期。在需要非空日期但其值无关紧要时使用。
  - PAST_INFINITY
```
public static final AbsoluteDate PAST_INFINITY
```
    过去方向无限远处的虚拟日期。
    
    另请参阅:
    
    TimeScales.getPastInfinity()
  - FUTURE_INFINITY
```
public static final AbsoluteDate FUTURE_INFINITY
```
    未来方向无限远处的虚拟日期。
    
    另请参阅:
    
    TimeScales.getFutureInfinity()
- Constructor Detail
  - AbsoluteDate
```
@DefaultDataContext
public AbsoluteDate()
```
    使用默认值（J2000_EPOCH）创建一个实例。
    此构造函数使用默认数据上下文。
    
    另请参阅:
    
    AbsoluteDate(DateTimeComponents, TimeScale)
  - AbsoluteDate
```
public AbsoluteDate(String location,
                    TimeScale timeScale)
```
    从位置（从字符串解析）在时间标度中构建一个实例。
    位置的支持格式主要是ISO-8601标准中定义的格式，精确子集在DateTimeComponents.parseDateTime(String)，DateComponents.parseDate(String)和TimeComponents.parseTime(String)中有解释。
    
    由于CCSDS ASCII日历分段时间代码是ISO-8601的简化版本，因此此构造函数也支持它。
    
    参数:
    
    location - 时间标度中的位置，必须是支持的格式
    
    timeScale - 时间标度
    
    抛出:
    
    IllegalArgumentException - 如果位置字符串不是支持的格式
  - AbsoluteDate
```
public AbsoluteDate(DateTimeComponents location,
                    TimeScale timeScale)
```
    从时间标度中的位置构建一个实例。
    
    参数：
    
    location - 时间标度中的位置
    
    timeScale - 时间标度
  - AbsoluteDate
```
public AbsoluteDate(DateComponents date,
                    TimeComponents time,
                    TimeScale timeScale)
```
    从时间标度中的位置构建一个实例。
    
    参数：
    
    date - 时间标度中的日期位置
    
    time - 时间标度中的时间位置
    
    timeScale - 时间标度
  - AbsoluteDate
```
public AbsoluteDate(int year,
                    int month,
                    int day,
                    int hour,
                    int minute,
                    double second,
                    TimeScale timeScale)
             throws IllegalArgumentException
```
    从时间标度中的位置构建一个实例。
    
    参数：
    
    year - 年份（可以是0或负数表示公元前年份）
    
    month - 月份，范围从1到12
    
    day - 日，范围从1到31
    
    hour - 小时，范围从0到23
    
    minute - 分钟，范围从0到59
    
    second - 秒，范围从0.0到60.0（不包括60.0）
    
    timeScale - 时间标度
    
    抛出：
    
    IllegalArgumentException - 如果给定的参数不一致（参数超出范围）
  - AbsoluteDate
```
public AbsoluteDate(int year,
                    Month month,
                    int day,
                    int hour,
                    int minute,
                    double second,
                    TimeScale timeScale)
             throws IllegalArgumentException
```
    从时间标度中的位置构建一个实例。
    
    参数：
    
    year - 年份（可以是0或负数表示公元前年份）
    
    month - 月份枚举
    
    day - 日，范围从1到31
    
    hour - 小时，范围从0到23
    
    minute - 分钟，范围从0到59
    
    second - 秒，范围从0.0到60.0（不包括60.0）
    
    timeScale - 时间标度
    
    抛出：
    
    IllegalArgumentException - 如果给定的参数不一致（参数超出范围）
  - AbsoluteDate
```
public AbsoluteDate(DateComponents date,
                    TimeScale timeScale)
             throws IllegalArgumentException
```
    从时间标度中的位置构建一个实例。
    小时设置为00:00:00.000。
    
    参数：
    
    date - 时间标度中的日期位置
    
    timeScale - 时间标度
    
    抛出：
    
    IllegalArgumentException - 如果给定的参数不一致（参数超出范围）
  - AbsoluteDate
```
public AbsoluteDate(int year,
                    int month,
                    int day,
                    TimeScale timeScale)
             throws IllegalArgumentException
```
    从时间标度中的位置构建一个实例。
    小时设置为00:00:00.000。
    
    参数：
    
    year - 年份（可以是0或负数表示公元前年份）
    
    month - 月份，范围从1到12
    
    day - 日，范围从1到31
    
    timeScale - 时间标度
    
    抛出：
    
    IllegalArgumentException - 如果给定的参数不一致（参数超出范围）
  - AbsoluteDate
```
public AbsoluteDate(int year,
                    Month month,
                    int day,
                    TimeScale timeScale)
             throws IllegalArgumentException
```
    从时间标度中的位置构建一个实例。
    小时设置为00:00:00.000。
    
    参数：
    
    year - 年份（可以是0或负数表示公元前年份）
    
    month - 月份枚举
    
    day - 日，范围从1到31
    
    timeScale - 时间标度
    
    抛出：
    
    IllegalArgumentException - 如果给定的参数不一致（参数超出范围）
  - AbsoluteDate
```
public AbsoluteDate(Date location,
                    TimeScale timeScale)
```
    从时间标度中的位置构建一个实例。
    
    参数：
    
    location - 时间标度中的位置
    
    timeScale - 时间标度
  - AbsoluteDate
```
public AbsoluteDate(Instant instant,
                    TimeScale timeScale)
```
    从瞬时和时间标度中构建一个实例。
    
    参数：
    
    instant - 时间标度中的瞬时
    
    timeScale - 时间标度
    
    自版本：
    
    12.0
  - AbsoluteDate
```
public AbsoluteDate(AbsoluteDate since,
                    double elapsedDuration)
```
    从相对于另一个瞬时的经过时间构建一个实例。
    重要说明：经过时间不是两个时间标度上的两次读数之间的差异。例如，在UTC时间标度中，导致读数为2005-12-31T23:59:59和2006-01-01T00:00:00的两个瞬时之间的持续时间不是1秒，而是一个秒表在这两个瞬时之间测量的经过时间为2秒，因为在这个时间标度中，2005年底引入了一个闰秒。
    
    此构造函数是durationFrom(AbsoluteDate)方法的反向操作。
    
    参数：
    
    since - 测量持续时间的起始瞬时
    
    elapsedDuration - 从since瞬时开始的物理经过时间，以常规时间标度测量
    
    另请参阅：
    
    durationFrom(AbsoluteDate)
  - AbsoluteDate
```
public AbsoluteDate(AbsoluteDate reference,
                    double apparentOffset,
                    TimeScale timeScale)
```
    从相对于另一个瞬时的表观时钟偏移构建一个实例，从特定时间标度的视角。
    重要说明：表观时钟偏移是两个时间标度上的两次读数之间的差异，而不是经过时间。例如，在UTC时间标度中，导致读数为2005-12-31T23:59:59和2006-01-01T00:00:00的两个瞬时之间的表观时钟偏移是1秒，但经过时间是2秒，因为在这个时间标度中，2005年底引入了一个闰秒。
    
    此构造函数是offsetFrom(AbsoluteDate, TimeScale)方法的反向操作。
    
    参数：
    
    reference - 参考瞬时
    
    apparentOffset - 相对于参考瞬时的表观时钟偏移（在指定时间标度上的两次读数之间的差异）
    
    timeScale - 定义偏移的时间标度
    
    另请参阅：
    
    offsetFrom(AbsoluteDate, TimeScale)
- Method Detail
  - parseCCSDSUnsegmentedTimeCode
```
@DefaultDataContext
public static AbsoluteDate parseCCSDSUnsegmentedTimeCode(byte preambleField1,
                                                                             byte preambleField2,
                                                                             byte[] timeField,
                                                                             AbsoluteDate agencyDefinedEpoch)
```
    从CCSDS Unsegmented Time Code (CUC)构建一个实例。
    CCSDS Unsegmented Time Code定义在蓝皮书中：CCSDS Time Code Format (CCSDS 301.0-B-4)，发布于2010年11月
    
    如果要解析的日期使用标准的第3版（2002年发布的CCSDS 301.0-B-3）格式，或者如果标准的第4版中引入的前导字段扩展未被使用，则preambleField2参数可以设置为0。
    
    如果使用CCSDS纪元，则此方法使用默认数据上下文。
    
    参数：
    
    preambleField1 - 指定格式的字段的第一个字节，通常不在数据接口中传输，因为对于给定的数据接口，它是恒定的
    
    preambleField2 - 指定格式的字段的第二个字节（2010年CCSDS标准修订版4中添加），通常不在数据接口中传输，因为对于给定的数据接口，它是恒定的（如果在preambleField1中未标记存在，则忽略该值）
    
    timeField - 包含时间代码的字节数组
    
    agencyDefinedEpoch - 参考纪元，如果前导字段指定使用CCSDS参考纪元（因此在这种情况下可能为null）
    
    返回：
    
    对应于指定日期的实例
    
    另请参阅：
    
    parseCCSDSUnsegmentedTimeCode(byte, byte, byte[], AbsoluteDate, AbsoluteDate)
  - parseCCSDSUnsegmentedTimeCode
```
public static AbsoluteDate parseCCSDSUnsegmentedTimeCode(byte preambleField1,
                                                         byte preambleField2,
                                                         byte[] timeField,
                                                         AbsoluteDate agencyDefinedEpoch,
                                                         AbsoluteDate ccsdsEpoch)
```
    从CCSDS Unsegmented Time Code (CUC)构建一个实例。
    CCSDS Unsegmented Time Code定义在蓝皮书中：CCSDS Time Code Format (CCSDS 301.0-B-4)，发布于2010年11月
    
    如果要解析的日期使用标准的第3版（2002年发布的CCSDS 301.0-B-3）格式，或者如果标准的第4版中引入的前导字段扩展未被使用，则preambleField2参数可以设置为0。
    
    参数:
    
    preambleField1 - 字段的第一个字节，指定格式，通常不在数据接口中传输，因为对于给定的数据接口是恒定的
    
    preambleField2 - 字段的第二个字节，指定格式（在2010年CCSDS标准的修订版4中添加），通常不在数据接口中传输，因为对于给定的数据接口是恒定的（如果在preambleField1中未标记存在，则忽略值）
    
    timeField - 包含时间码的字节数组
    
    agencyDefinedEpoch - 参考时期，如果前导字段指定使用CCSDS参考时期（因此在这种情况下可能为null）
    
    ccsdsEpoch - 参考时期，如果前导字段指定使用机构时期。
    
    返回:
    
    对应于指定日期的实例
    
    自版本:
    
    10.1
  - parseCCSDSDaySegmentedTimeCode
```
@DefaultDataContext
public static AbsoluteDate parseCCSDSDaySegmentedTimeCode(byte preambleField,
                                                                              byte[] timeField,
                                                                              DateComponents agencyDefinedEpoch)
```
    从CCSDS日分段时间码（CDS）构建实例。
    CCSDS日分段时间码在2010年11月出版的蓝皮书中定义：CCSDS时间码格式（CCSDS 301.0-B-4）
    
    此方法使用默认数据上下文。
    
    参数:
    
    preambleField - 指定格式的字段，通常不在数据接口中传输，因为对于给定的数据接口是恒定的
    
    timeField - 包含时间码的字节数组
    
    agencyDefinedEpoch - 参考时期，如果前导字段指定使用CCSDS参考时期（因此在这种情况下可能为null）
    
    返回:
    
    对应于指定日期的实例
    
    另请参阅:
    
    parseCCSDSDaySegmentedTimeCode(byte, byte[], DateComponents, TimeScale)
  - parseCCSDSDaySegmentedTimeCode
```
public static AbsoluteDate parseCCSDSDaySegmentedTimeCode(byte preambleField,
                                                          byte[] timeField,
                                                          DateComponents agencyDefinedEpoch,
                                                          TimeScale utc)
```
    从CCSDS日分段时间码（CDS）构建实例。
    CCSDS日分段时间码在2010年11月出版的蓝皮书中定义：CCSDS时间码格式（CCSDS 301.0-B-4）
    
    参数:
    
    preambleField - 指定格式的字段，通常不在数据接口中传输，因为对于给定的数据接口是恒定的
    
    timeField - 包含时间码的字节数组
    
    agencyDefinedEpoch - 参考时期，如果前导字段指定使用CCSDS参考时期（因此在这种情况下可能为null）
    
    utc - 用于计算日期和时间分量的时间标度。
    
    返回:
    
    对应于指定日期的实例
    
    自版本:
    
    10.1
  - parseCCSDSCalendarSegmentedTimeCode
```
@DefaultDataContext
public static AbsoluteDate parseCCSDSCalendarSegmentedTimeCode(byte preambleField,
                                                                                   byte[] timeField)
```
    从CCSDS日历分段时间码（CCS）构建实例。
    CCSDS日历分段时间码在2010年11月出版的蓝皮书中定义：CCSDS时间码格式（CCSDS 301.0-B-4）
    
    此方法使用默认数据上下文。
    
    参数:
    
    preambleField - 指定格式的字段，通常不在数据接口中传输，因为对于给定的数据接口是恒定的
    
    timeField - 包含时间码的字节数组
    
    返回:
    
    对应于指定日期的实例
    
    另请参阅:
    
    parseCCSDSCalendarSegmentedTimeCode(byte, byte[], TimeScale)
  - parseCCSDSCalendarSegmentedTimeCode
```
public static AbsoluteDate parseCCSDSCalendarSegmentedTimeCode(byte preambleField,
                                                               byte[] timeField,
                                                               TimeScale utc)
```
    从CCSDS日历分段时间码（CCS）构建实例。
    CCSDS日历分段时间码在2010年11月出版的蓝皮书中定义：CCSDS时间码格式（CCSDS 301.0-B-4）
    
    参数:
    
    preambleField - 指定格式的字段，通常不在数据接口中传输，因为对于给定的数据接口是恒定的
    
    timeField - 包含时间码的字节数组
    
    utc - 用于计算日期和时间分量的时间标度。
    
    返回:
    
    对应于指定日期的实例
    
    自版本:
    
    10.1
  - createJDDate
```
public static AbsoluteDate createJDDate(int jd,
                                        double secondsSinceNoon,
                                        TimeScale timeScale)
```
    构建对应于儒略日日期的实例。
    
    参数:
    
    jd - 儒略日
    
    secondsSinceNoon - 一天中的秒数（注意，儒略日从中午开始，因此0.0是中午）
    
    timeScale - 定义一天中秒数的时间标度
    
    返回:
    
    一个新的实例
  - createMJDDate
```
public static AbsoluteDate createMJDDate(int mjd,
                                         double secondsInDay,
                                         TimeScale timeScale)
                                  throws OrekitIllegalArgumentException
```
    构建对应于修正儒略日日期的实例。
    
    参数:
    
    mjd - 修正儒略日
    
    secondsInDay - 一天中的秒数
    
    timeScale - 定义一天中秒数的时间标度
    
    返回:
    
    一个新的实例
    
    抛出:
    
    OrekitIllegalArgumentException - 如果秒数超出范围
  - createJulianEpoch
```
@DefaultDataContext
public static AbsoluteDate createJulianEpoch(double julianEpoch)
```
    构建对应于儒略纪元（JE）的实例。
    根据Lieske的论文：基于IAU（1976）天文常数体系的岁差矩阵，天文学与天体物理学，第73卷，第3期，1979年3月，第282-284页，儒略纪元与儒略历日期相关如下：
```
 JE = 2000.0 + (JED - 2451545.0) / 365.25
 
```
    此方法反转上述公式，并从儒略纪元计算出一个AbsoluteDate。
    
    此方法使用默认数据上下文。
    参数:
    
    julianEpoch - 儒略纪元，如2000.0用于定义经典参考J2000.0
    
    返回:
    
    一个新的实例
    
    另请参阅:
    
    J2000_EPOCH, createBesselianEpoch(double), TimeScales.createJulianEpoch(double)
  - createBesselianEpoch
```
@DefaultDataContext
public static AbsoluteDate createBesselianEpoch(double besselianEpoch)
```
    构建对应于贝塞尔纪元（BE）的实例。
    根据Lieske的论文：基于IAU（1976）天文常数体系的岁差矩阵，天文学与天体物理学，第73卷，第3期，1979年3月，第282-284页，贝塞尔纪元与儒略历日期相关如下：
```
 BE = 1900.0 + (JED - 2415020.31352) / 365.242198781
 
```
    此方法反转上述公式，并从贝塞尔纪元计算出一个AbsoluteDate。
    
    此方法使用默认数据上下文。
    参数:
    
    besselianEpoch - 贝塞尔纪元，如1950用于定义经典参考B1950.0
    
    返回:
    
    一个新的实例
    
    另请参阅:
    
    createJulianEpoch(double), TimeScales.createBesselianEpoch(double)
  - shiftedBy
```
public AbsoluteDate shiftedBy(double dt)
```
    获取一个时间偏移的日期。
    调用此方法等效于调用new AbsoluteDate(this, dt)。
    
    接口中指定:
    
    shiftedBy 在接口 TimeShiftable<AbsoluteDate>
    
    参数:
    
    dt - 以秒为单位的时间偏移
    
    返回:
    
    一个新的日期，相对于实例进行了偏移（实例是不可变的）
    
    另请参阅:
    
    PVCoordinates.shiftedBy(double), Attitude.shiftedBy(double), Orbit.shiftedBy(double), SpacecraftState.shiftedBy(double)
  - durationFrom
```
public double durationFrom(AbsoluteDate instant)
```
    计算两个瞬时之间的物理经过时间。
    返回的持续时间是两个瞬时之间物理经过的秒数，以地球表面的常规时间尺度来衡量（即TAI尺度、TT尺度或GPS尺度）。这是唯一一个具有物理意义的持续时间方法。
    
    此方法与使用第二个参数设置为上述任一常规尺度之一调用offsetFrom(AbsoluteDate, TimeScale)的结果相同（计算更少）。
    
    此方法是AbsoluteDate(AbsoluteDate, double)构造函数的逆方法。
    
    参数：
    
    instant - 要从实例中减去的瞬时
    
    返回：
    
    两个瞬时之间的偏移量（如果实例在参数之后则为正）
    
    另请参阅：
    
    offsetFrom(AbsoluteDate, TimeScale)，AbsoluteDate(AbsoluteDate, double)
  - offsetFrom
```
public double offsetFrom(AbsoluteDate instant,
                         TimeScale timeScale)
```
    计算两个瞬时之间的视钟偏移，从特定的时间尺度的视角。
    偏移量是在给定时间尺度中计算的秒数，表示两个瞬时位置之间的秒数，消除了所有时间尺度的不规则性（即认为所有天都恰好是86400秒长）。如果时间尺度不规则，此方法将给出可能没有物理意义的结果。例如，自2005年底引入闰秒以来，2005-12-31T23:59:59和2006-01-01T00:00:00之间的视偏移量为1秒，但由durationFrom(AbsoluteDate)方法返回的相应时间间隔的物理持续时间为2秒。
    
    此方法是AbsoluteDate(AbsoluteDate, double, TimeScale)构造函数的逆方法。
    
    参数：
    
    instant - 要从实例中减去的瞬时
    
    timeScale - 应计算偏移量的时间尺度
    
    返回：
    
    两个瞬时之间的视钟偏移量（如果实例在参数之后则为正）
    
    另请参阅：
    
    durationFrom(AbsoluteDate)，AbsoluteDate(AbsoluteDate, double, TimeScale)
  - timeScalesOffset
```
public double timeScalesOffset(TimeScale scale1,
                               TimeScale scale2)
```
    计算当前瞬时两个时间尺度之间的偏移量。
    偏移量定义为l₁-l₂，其中l₁是scale1时间尺度中瞬时的位置，l₂是scale2时间尺度中瞬时的位置。
    
    参数：
    
    scale1 - 第一个时间尺度
    
    scale2 - 第二个时间尺度
    
    返回：
    
    当前瞬时两个时间尺度之间的偏移量（以秒为单位）
  - toDate
```
public Date toDate(TimeScale timeScale)
```
    将实例转换为Java Date。
    转换为Date类会导致精度损失，因为Date类不提供亚毫秒信息。Java Dates被认为是某些时间尺度中的位置。
    
    参数：
    
    timeScale - 要使用的时间尺度
    
    返回：
    
    表示时间尺度中瞬时位置的Date实例
  - getComponents
```
public DateTimeComponents getComponents(TimeScale timeScale)
```
    将实例拆分为日期/时间组件。
    
    参数：
    
    timeScale - 要使用的时间尺度
    
    返回：
    
    日期/时间组件
  - getComponents
```
@DefaultDataContext
public DateTimeComponents getComponents(int minutesFromUTC)
```
    将实例拆分为本地时间的日期/时间组件。
    此方法使用默认数据上下文。
    
    参数：
    
    minutesFromUTC - 与UTC的偏移量（东UTC为正，西UTC为负）
    
    返回：
    
    日期/时间组件
    
    自版本：
    
    7.2
    
    另请参阅：
    
    getComponents(int, TimeScale)
  - getComponents
```
public DateTimeComponents getComponents(int minutesFromUTC,
                                        TimeScale utc)
```
    将实例拆分为本地时间的日期/时间组件。
    
    参数：
    
    minutesFromUTC - 与UTC的偏移量（东UTC为正，西UTC为负）
    
    utc - 用于计算日期和时间组件的时间尺度。
    
    返回：
    
    日期/时间组件
    
    自版本：
    
    10.1
  - getComponents
```
@DefaultDataContext
public DateTimeComponents getComponents(TimeZone timeZone)
```
    将实例拆分为时区的日期/时间组件。
    此方法使用默认数据上下文。
    
    参数：
    
    timeZone - 时区
    
    返回：
    
    日期/时间组件
    
    自版本：
    
    7.2
    
    另请参阅：
    
    getComponents(TimeZone, TimeScale)
  - getComponents
```
public DateTimeComponents getComponents(TimeZone timeZone,
                                        TimeScale utc)
```
    将实例拆分为时区的日期/时间组件。
    
    参数：
    
    timeZone - 时区
    
    utc - 用于计算日期和时间组件的时间尺度。
    
    返回：
    
    日期/时间组件
    
    自版本：
    
    10.1
  - compareTo
```
public int compareTo(AbsoluteDate date)
```
    将实例与另一个日期进行比较。
    
    由以下接口指定：
    
    compareTo 在接口 Comparable<AbsoluteDate>
    
    参数：
    
    date - 要将实例与之比较的其他日期
    
    返回：
    
    如果此日期在指定日期之前、同时或之后，则为负整数、零或正整数。
  - getDate
```
public AbsoluteDate getDate()
```
    获取日期。
    
    由以下接口指定：
    
    getDate 在接口 TimeStamped
    
    返回：
    
    附加到对象的日期
  - equals
```
public boolean equals(Object date)
```
    检查实例是否表示与另一个实例相同的时间。
    
    覆盖：
    
    equals 在类 Object
    
    参数：
    
    date - 其他日期
    
    返回：
    
    如果实例和其他日期引用相同的瞬时，则为true
  - isEqualTo
```
public boolean isEqualTo(TimeStamped other)
```
    检查实例是否表示与另一个时间相同的时间。
    
    参数：
    
    other - 要将此日期与之比较的瞬时
    
    返回：
    
    如果实例和参数引用相同的瞬时，则为true
    
    自版本：
    
    10.1
    
    另请参阅：
    
    isCloseTo(TimeStamped, double)
  - isCloseTo
```
public boolean isCloseTo(TimeStamped other,
                         double tolerance)
```
    检查实例时间是否接近另一个时间。
    
    参数:
    
    other - 要与此日期进行比较的时刻
    
    tolerance - 两个时刻被认为彼此接近的时间间隔（以秒为单位）
    
    返回:
    
    如果实例和参数之间的持续时间严格低于容差，则为true
    
    自从:
    
    10.1
    
    另请参阅:
    
    isEqualTo(TimeStamped)
  - isBefore
```
public boolean isBefore(TimeStamped other)
```
    检查实例是否表示比另一个时间严格早。
    
    参数:
    
    other - 要与此日期进行比较的时刻
    
    返回:
    
    如果实例在时间顺序上严格早于参数，则为true
    
    自从:
    
    10.1
    
    另请参阅:
    
    isBeforeOrEqualTo(TimeStamped)
  - isAfter
```
public boolean isAfter(TimeStamped other)
```
    检查实例是否表示比另一个时间严格晚。
    
    参数:
    
    other - 要与此日期进行比较的时刻
    
    返回:
    
    如果实例在时间顺序上严格晚于参数，则为true
    
    自从:
    
    10.1
    
    另请参阅:
    
    isAfterOrEqualTo(TimeStamped)
  - isBeforeOrEqualTo
```
public boolean isBeforeOrEqualTo(TimeStamped other)
```
    检查实例是否表示比另一个时间早或等于。
    
    参数:
    
    other - 要与此日期进行比较的时刻
    
    返回:
    
    如果实例在时间顺序上早于（或等于）参数，则为true
    
    自从:
    
    10.1
    
    另请参阅:
    
    isBefore(TimeStamped)
  - isAfterOrEqualTo
```
public boolean isAfterOrEqualTo(TimeStamped other)
```
    检查实例是否表示比另一个时间晚或等于。
    
    参数:
    
    other - 要与此日期进行比较的时刻
    
    返回:
    
    如果实例在时间顺序上晚于（或等于）参数，则为true
    
    自从:
    
    10.1
    
    另请参阅:
    
    isAfterOrEqualTo(TimeStamped)
  - isBetween
```
public boolean isBetween(TimeStamped boundary,
                         TimeStamped otherBoundary)
```
    检查实例是否表示在另外两个表示时间跨度边界的时间之间。两个边界可以以任何顺序提供：换句话说，boundary表示的时间是在otherBoundary之前还是之后，都不会改变此方法的结果。
    
    参数:
    
    boundary - 时间跨度的一端
    
    otherBoundary - 时间跨度的另一端
    
    返回:
    
    如果实例在时间顺序上严格介于两个参数之间，则为true
    
    自从:
    
    10.1
    
    另请参阅:
    
    isBetweenOrEqualTo(TimeStamped, TimeStamped)
  - isBetweenOrEqualTo
```
public boolean isBetweenOrEqualTo(TimeStamped boundary,
                                  TimeStamped otherBoundary)
```
    检查实例是否表示在另外两个表示时间跨度边界的时间之间，或等于其中一个。两个边界可以以任何顺序提供：换句话说，boundary表示的时间是在otherBoundary之前还是之后，都不会改变此方法的结果。
    
    参数:
    
    boundary - 时间跨度的一端
    
    otherBoundary - 时间跨度的另一端
    
    返回:
    
    如果实例在时间顺序上介于两个参数之间（或至少等于其中一个），则为true
    
    自从:
    
    10.1
    
    另请参阅:
    
    isBetween(TimeStamped, TimeStamped)
  - hashCode
```
public int hashCode()
```
    获取此日期的哈希码。
    
    覆盖:
    
    hashCode 在类 Object中
    
    返回:
    
    哈希码
  - toString
```
@DefaultDataContext
public String toString()
```
    获取实例位置的字符串表示，秒值精度高达16位。
    由于此方法用于异常消息和错误处理，因此会尽一切努力返回时刻的某种表示。如果默认数据上下文中提供了UTC，则将其用于以UTC格式化字符串。如果没有，则使用TAI。最后，如果前面的尝试失败，此方法将退回将此类的内部表示转换为字符串。
    
    此方法使用默认数据上下文。
    
    覆盖:
    
    toString 在类 Object中
    
    返回:
    
    实例的字符串表示，如果默认数据上下文中提供了UTC，则为ISO-8601格式。
    
    另请参阅:
    
    toString(TimeScale), toStringRfc3339(TimeScale), DateTimeComponents.toString(int, int)
  - toString
```
public String toString(TimeScale timeScale)
```
    获取实例位置的ISO-8601格式字符串表示，不带UTC偏移量，秒值精度高达16位。
    
    参数:
    
    timeScale - 要使用的时间标度
    
    返回:
    
    实例的字符串表示。
    
    另请参阅:
    
    toStringRfc3339(TimeScale), DateTimeComponents.toString(int, int)
  - toString
```
@DefaultDataContext
public String toString(int minutesFromUTC)
```
    获取本地时间的实例位置的字符串表示。
    此方法使用默认数据上下文。
    
    参数:
    
    minutesFromUTC - 与UTC的偏移量（东部UTC为正，西部UTC为负）中的分钟数。
    
    返回:
    
    实例的字符串表示，以毫秒精度的ISO-8601格式
    
    自从:
    
    7.2
    
    另请参阅:
    
    toString(int, TimeScale)
  - toString
```
public String toString(int minutesFromUTC,
                       TimeScale utc)
```
    获取本地时间的实例位置的字符串表示。
    
    参数:
    
    minutesFromUTC - 与UTC的偏移量（东部UTC为正，西部UTC为负）中的分钟数。
    
    utc - 用于计算日期和时间组件的时间标度。
    
    返回:
    
    实例的字符串表示，以毫秒精度的ISO-8601格式
    
    自从:
    
    10.1
    
    另请参阅:
    
    getComponents(int, TimeScale), DateTimeComponents.toString(int, int)
  - toString
```
@DefaultDataContext
public String toString(TimeZone timeZone)
```
    获取时区的实例位置的字符串表示。
    此方法使用默认数据上下文。
    
    参数:
    
    timeZone - 时区
    
    返回:
    
    实例的字符串表示，以毫秒精度的ISO-8601格式
    
    自从:
    
    7.2
    
    另请参阅:
    
    toString(TimeZone, TimeScale)
  - toString
```
public String toString(TimeZone timeZone,
                       TimeScale utc)
```
    获取时区的实例位置的字符串表示。
    
    参数:
    
    timeZone - 时区
    
    utc - 用于计算日期和时间组件的时间标度。
    
    返回:
    
    实例的字符串表示，采用ISO-8601格式，精确到毫秒
    
    自版本:
    
    10.1
    
    另请参阅:
    
    getComponents(TimeZone, TimeScale), DateTimeComponents.toString(int, int)
  - toStringRfc3339
```
public String toStringRfc3339(TimeScale utc)
```
    将给定日期表示为字符串，格式符合RFC 3339。RFC3339是ISO 8601的受限子集，具有明确定义的语法。秒值中包含足够的数字，以避免四舍五入到下一分钟。
    此方法与toString(TimeScale)不同，因为它在末尾包含一个"Z"以指示时区，并具有足够的精度来表示时间点，而不会四舍五入到下一分钟。
    
    RFC3339无法表示公元前年份、10000年或更多年份、100小时或更多的时区偏移或NaN。在这些情况下，此方法返回的值将不是有效的RFC3339格式。
    
    参数:
    
    utc - 时间标度。
    
    返回:
    
    RFC 3339格式字符串。
    
    另请参阅:
    
    RFC 3339, DateTimeComponents.toStringRfc3339(), toString(TimeScale), getComponents(TimeScale)
  - toStringWithoutUtcOffset
```
public String toStringWithoutUtcOffset(TimeScale timeScale,
                                       int fractionDigits)
```
    返回此日期时间的字符串表示，四舍五入到给定精度。
    使用的格式是ISO8601，不包括UTC偏移。
    
    调用toStringWithoutUtcOffset(DataContext.getDefault().getTimeScales().getUTC(), 3)将模拟Orekit 10及更早版本中toString()的行为。请注意，此方法更准确，因为它正确处理闰秒期间的四舍五入。
    
    参数:
    
    timeScale - 用于计算组件的时间标度。
    
    fractionDigits - 字符串表示中小数点后要包含的数字位数。首先根据需要四舍五入日期和时间。fractionDigits必须大于或等于0。
    
    返回:
    
    此日期、时间和UTC偏移的字符串表示
    
    自版本:
    
    11.1
    
    另请参阅:
    
    toString(TimeScale), toStringRfc3339(TimeScale), DateTimeComponents.toString(int, int), DateTimeComponents.toStringWithoutUtcOffset(int, int)

Class AbsoluteDate

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.orekit.time.TimeStamped

Field Detail

JULIAN_EPOCH

MODIFIED_JULIAN_EPOCH

FIFTIES_EPOCH

CCSDS_EPOCH

GALILEO_EPOCH

GPS_EPOCH

QZSS_EPOCH

IRNSS_EPOCH

BEIDOU_EPOCH

GLONASS_EPOCH

J2000_EPOCH

JAVA_EPOCH

ARBITRARY_EPOCH

PAST_INFINITY

FUTURE_INFINITY

Constructor Detail

AbsoluteDate

AbsoluteDate

AbsoluteDate

AbsoluteDate

AbsoluteDate

AbsoluteDate

AbsoluteDate

AbsoluteDate

AbsoluteDate

AbsoluteDate

AbsoluteDate

AbsoluteDate

AbsoluteDate

Method Detail

parseCCSDSUnsegmentedTimeCode

parseCCSDSUnsegmentedTimeCode

parseCCSDSDaySegmentedTimeCode

parseCCSDSDaySegmentedTimeCode

parseCCSDSCalendarSegmentedTimeCode

parseCCSDSCalendarSegmentedTimeCode

createJDDate

createMJDDate

createJulianEpoch

createBesselianEpoch

shiftedBy

durationFrom

offsetFrom

timeScalesOffset

toDate

getComponents

getComponents

getComponents

getComponents

getComponents

compareTo

getDate

equals

isEqualTo

isCloseTo

isBefore

isAfter

isBeforeOrEqualTo

isAfterOrEqualTo

isBetween

isBetweenOrEqualTo

hashCode

toString

toString

toString

toString

toString

toString

toStringRfc3339

toStringWithoutUtcOffset