FieldAbsoluteDate (OREKIT 12.0.1 API)

java.lang.Object
- org.orekit.time.FieldAbsoluteDate<T>

Type Parameters:

T - type of the field elements

All Implemented Interfaces:

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

由于实例不绑定到特定的时间尺度，所有与日期在某个时间尺度内的位置相关的方法都需要提供时间尺度作为参数。因此，可以在一个时间尺度中定义日期并在另一个时间尺度中使用它。这样的用法示例如下：
```
   DateTimeComponents utcComponents = readNextDate();
   FieldAbsoluteDate<T> date = new FieldAbsoluteDate<>(utcComponents, TimeScalesFactory.getUTC());
   writeNextDate(date.getComponents(TimeScalesFactory.getTAI()));
 
```
有两种互补的视图：
- 位置视图（主要用于输入/输出或转换）
  
  位置表示一个事件相对于一个时间尺度的坐标。相关方法有FieldAbsoluteDate(Field, DateComponents, TimeComponents, TimeScale)、FieldAbsoluteDate(Field, int, int, int, int, int, double, TimeScale)、FieldAbsoluteDate(Field, int, int, int, TimeScale)、FieldAbsoluteDate(Field, Date, TimeScale)、createGPSDate(int, CalculusFieldElement)、parseCCSDSCalendarSegmentedTimeCode(byte, byte[])、toDate(TimeScale)、toString(timeScale)、toString()和timeScalesOffset(org.orekit.time.TimeScale, org.orekit.time.TimeScale)。
- 偏移视图（主要用于物理计算）
  
  偏移表示两个事件（该类的两个实例）之间的时间流逝或持续时间。它们以秒为单位计数，是连续的，并且可以使用仅具有几乎完美秒表的方法来测量。相关方法有FieldAbsoluteDate(FieldAbsoluteDate, double)、parseCCSDSUnsegmentedTimeCode(Field, byte, byte, byte[], FieldAbsoluteDate)、parseCCSDSDaySegmentedTimeCode(Field, byte, byte[], DateComponents)、durationFrom(FieldAbsoluteDate)、compareTo(FieldAbsoluteDate)、equals(Object)和hashCode()。
已定义了一些在空间系统中常用的参考时刻。这些时刻可以用作偏移计算的基础。支持的时刻是：getJulianEpoch(Field)、getModifiedJulianEpoch(Field)、getFiftiesEpoch(Field)、getCCSDSEpoch(Field)、getGalileoEpoch(Field)、getGPSEpoch(Field)、getJ2000Epoch(Field)、getJavaEpoch(Field)。还有两个工厂方法createJulianEpoch(CalculusFieldElement)和createBesselianEpoch(CalculusFieldElement)，可用于计算其他参考时刻，如J1900.0或B1950.0。除了这些参考时刻外，还定义了两个其他常量以方便使用：getPastInfinity(Field)和getFutureInfinity(Field)，当日期尚未初始化时可以用作虚拟日期，或用于初始化搜索最小或最大日期的循环。

FieldAbsoluteDate<T>类的实例保证是不可变的。
Author:

Luc Maisonobe

See Also:

TimeScale, TimeStamped, ChronologicalComparator

Constructor Summary

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

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`compareTo(FieldAbsoluteDate<T> date)` 与另一个日期实例进行比较。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`createBesselianEpoch(T besselianEpoch)` 构建一个对应于Besselian Epoch（BE）的实例。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`createBesselianEpoch(T besselianEpoch, TimeScales timeScales)` 构建一个对应于Besselian Epoch（BE）的实例。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`createGPSDate(int weekNumber, T milliInWeek)` 构建一个对应于GPS日期的实例。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`createGPSDate(int weekNumber, T milliInWeek, TimeScale gps)` 构建一个对应于GPS日期的实例。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`createJDDate(int jd, T secondsSinceNoon, TimeScale timeScale)` 构建一个对应于儒略日日期的实例。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`createJulianEpoch(T julianEpoch)` 构建一个对应于儒略纪元（JE）的实例。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`createJulianEpoch(T julianEpoch, TimeScales timeScales)` 构建一个对应于儒略纪元（JE）的实例。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`createMJDDate(int mjd, T secondsInDay, TimeScale timeScale)` 构建一个对应于修正儒略日日期的实例。
`T`	`durationFrom(AbsoluteDate instant)` 计算两个时刻之间的物理经过时间。
`T`	`durationFrom(FieldAbsoluteDate<T> instant)` 计算两个时刻之间的物理经过时间。
`boolean`	`equals(Object date)` 检查实例是否表示与另一个实例相同的时间。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`getArbitraryEpoch(org.hipparchus.Field<T> field)` 获取任意日期。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`getCCSDSEpoch(org.hipparchus.Field<T> field)` CCSDS时间代码格式（CCSDS 301.0-B-4）的参考时刻：
`DateTimeComponents`	`getComponents(int minutesFromUTC)` 将实例拆分为本地时间的日期/时间组件。
`DateTimeComponents`	`getComponents(int minutesFromUTC, TimeScale utc)` 将实例拆分为本地时间的日期/时间组件。
`DateTimeComponents`	`getComponents(TimeScale timeScale)` 将实例拆分为日期/时间组件。
`DateTimeComponents`	`getComponents(TimeZone timeZone)` 将实例拆分为时区的日期/时间组件。
`DateTimeComponents`	`getComponents(TimeZone timeZone, TimeScale utc)` 将实例拆分为特定时区的日期/时间组件。
`FieldAbsoluteDate<T>`	`getDate()` 获取日期。
`org.hipparchus.Field<T>`	`getField()` 获取字段。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`getFiftiesEpoch(org.hipparchus.Field<T> field)` 1950年日期的参考时期：1950-01-01T00:00:00 地球时间。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`getFutureInfinity(org.hipparchus.Field<T> field)` 未来方向上的无限大虚拟日期。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`getGalileoEpoch(org.hipparchus.Field<T> field)` Galileo系统时间的参考时期：1999-08-22T00:00:00 UTC。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`getGPSEpoch(org.hipparchus.Field<T> field)` GPS周的参考时期：1980-01-06T00:00:00 GPS时间。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`getJ2000Epoch(org.hipparchus.Field<T> field)` J2000.0参考时期：2000-01-01T12:00:00 地球时间（不是 UTC）。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`getJavaEpoch(org.hipparchus.Field<T> field)` Java参考时期：1970-01-01T00:00:00 世界时。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`getJulianEpoch(org.hipparchus.Field<T> field)` 儒略日期的参考时期：-4712-01-01T12:00:00 地球时间。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`getModifiedJulianEpoch(org.hipparchus.Field<T> field)` 修正儒略日期的参考时期：1858-11-17T00:00:00 地球时间。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`getPastInfinity(org.hipparchus.Field<T> field)` 过去方向上的无限大虚拟日期。
`int`	`hashCode()` 为此日期获取哈希码。
`boolean`	`hasZeroField()` 检查字段是否在语义上等于零。
`boolean`	`isAfter(FieldTimeStamped<T> other)` 检查实例是否表示严格晚于另一个时间。
`boolean`	`isAfterOrEqualTo(FieldTimeStamped<T> other)` 检查实例是否表示晚于或等于另一个时间。
`boolean`	`isBefore(FieldTimeStamped<T> other)` 检查实例是否表示严格早于另一个时间。
`boolean`	`isBeforeOrEqualTo(FieldTimeStamped<T> other)` 检查实例是否表示早于或等于另一个时间。
`boolean`	`isBetween(FieldTimeStamped<T> boundary, FieldTimeStamped<T> otherBoundary)` 检查实例是否严格介于另外两个表示时间跨度边界的时间之间。
`boolean`	`isBetweenOrEqualTo(FieldTimeStamped<T> boundary, FieldTimeStamped<T> otherBoundary)` 检查实例是否介于另外两个表示时间跨度边界的时间之间，或等于其中一个。
`boolean`	`isCloseTo(FieldTimeStamped<T> other, double tolerance)` 检查实例时间是否接近另一个时间。
`boolean`	`isEqualTo(FieldTimeStamped<T> other)` 检查实例是否表示与另一个时间相同。
`T`	`offsetFrom(FieldAbsoluteDate<T> instant, TimeScale timeScale)` 计算两个瞬时之间的视钟偏移量从特定的`时间标度`的视角。
`FieldAbsoluteDate<T>`	`parseCCSDSCalendarSegmentedTimeCode(byte preambleField, byte[] timeField)` 从CCSDS日历分段时间代码（CCS）构建实例。
`FieldAbsoluteDate<T>`	`parseCCSDSCalendarSegmentedTimeCode(byte preambleField, byte[] timeField, TimeScale utc)` 从CCSDS日历分段时间代码（CCS）构建实例。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`parseCCSDSDaySegmentedTimeCode(org.hipparchus.Field<T> field, byte preambleField, byte[] timeField, DateComponents agencyDefinedEpoch)` 从CCSDS日分段时间代码（CDS）构建实例。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`parseCCSDSDaySegmentedTimeCode(org.hipparchus.Field<T> field, byte preambleField, byte[] timeField, DateComponents agencyDefinedEpoch, TimeScale utc)` 从CCSDS日分段时间代码（CDS）构建实例。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`parseCCSDSUnsegmentedTimeCode(org.hipparchus.Field<T> field, byte preambleField1, byte preambleField2, byte[] timeField, FieldAbsoluteDate<T> agencyDefinedEpoch)` 从CCSDS非分段时间代码（CUC）构建实例。
`static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T>`	`parseCCSDSUnsegmentedTimeCode(org.hipparchus.Field<T> field, byte preambleField1, byte preambleField2, byte[] timeField, FieldAbsoluteDate<T> agencyDefinedEpoch, FieldAbsoluteDate<T> ccsdsEpoch)` 从CCSDS非分段时间代码（CUC）构建实例。
`FieldAbsoluteDate<T>`	`shiftedBy(double dt)` 获取一个时间偏移后的日期。
`FieldAbsoluteDate<T>`	`shiftedBy(T dt)` 获取一个时间偏移后的日期。
`T`	`timeScalesOffset(TimeScale scale1, TimeScale scale2)` 计算当前瞬时两个时间标度之间的偏移量。
`AbsoluteDate`	`toAbsoluteDate()` 将FieldAbsoluteDate转换为AbsoluteDate。
`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)` 获取时区的实例位置的字符串表示。

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

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

- Constructor Detail
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(org.hipparchus.Field<T> field,
                         AbsoluteDate date)
```
    从AbsoluteDate构建实例。
    
    参数：
    
    field - 默认使用的字段
    
    date - 要实例化为FieldAbsoluteDate的AbsoluteDate
  - FieldAbsoluteDate
```
@DefaultDataContext
public FieldAbsoluteDate(org.hipparchus.Field<T> field)
```
    使用默认值（getJ2000Epoch(Field)）创建一个实例。
    此方法使用默认数据上下文。
    
    参数：
    
    field - 默认使用的字段
    
    另请参见：
    
    FieldAbsoluteDate(Field, AbsoluteDate)
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(FieldAbsoluteDate<T> since,
                         T elapsedDuration)
```
    从另一个瞬时的经过持续时间构建实例。
    重要说明：经过的持续时间不是两个时间标度上的两次读数之间的差异。例如，在UTC时间标度上导致读数2005-12-31T23:59:59和2006-01-01T00:00:00之间的持续时间不是1秒，而是一个秒表在这两个瞬时之间测量的经过时间为2秒，因为在这个时间标度中在2005年底引入了一个闰秒。
    
    此构造函数是durationFrom(FieldAbsoluteDate)方法的反向操作。
    
    参数：
    
    since - 测量持续时间的起始瞬时
    
    elapsedDuration - 从since瞬时开始的物理经过时间，在常规时间标度上测量
    
    另请参见：
    
    durationFrom(FieldAbsoluteDate)
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(org.hipparchus.Field<T> field,
                         String location,
                         TimeScale timeScale)
```
    从一个时间标度中的位置（从字符串解析）构建实例。
    位置的支持格式主要是ISO-8601标准中定义的格式，精确的子集在DateTimeComponents.parseDateTime(String)，DateComponents.parseDate(String)和TimeComponents.parseTime(String)中有解释。
    
    由于CCSDS ASCII日历分段时间代码是ISO-8601的简化版本，因此此构造函数也支持它。
    
    参数：
    
    field - 默认使用的字段
    
    location - 时间标度中的位置，必须是支持的格式
    
    timeScale - 时间标度
    
    抛出：
    
    IllegalArgumentException - 如果位置字符串不是支持的格式
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(org.hipparchus.Field<T> field,
                         DateTimeComponents location,
                         TimeScale timeScale)
```
    从一个时间标度中的位置构建实例。
    
    参数：
    
    field - 默认使用的字段
    
    location - 时间标度中的位置
    
    timeScale - 时间标度
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(org.hipparchus.Field<T> field,
                         DateComponents date,
                         TimeComponents time,
                         TimeScale timeScale)
```
    从一个时间标度中的位置构建实例。
    
    参数：
    
    field - 默认使用的字段
    
    date - 时间标度中的日期位置
    
    time - 时间标度中的时间位置
    
    timeScale - 时间标度
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(org.hipparchus.Field<T> field,
                         int year,
                         int month,
                         int day,
                         int hour,
                         int minute,
                         double second,
                         TimeScale timeScale)
                  throws IllegalArgumentException
```
    从一个时间标度中的位置构建实例。
    
    参数：
    
    field - 默认使用的字段
    
    year - 年份（BC年份可能为0或负数）
    
    month - 月份，从1到12
    
    day - 日期，从1到31
    
    hour - 小时，从0到23
    
    minute - 分钟，从0到59
    
    second - 秒，从0.0到60.0（不包括）
    
    timeScale - 时间标度
    
    抛出：
    
    IllegalArgumentException - 如果给定的参数不一致（参数超出范围）
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(org.hipparchus.Field<T> field,
                         int year,
                         Month month,
                         int day,
                         int hour,
                         int minute,
                         double second,
                         TimeScale timeScale)
                  throws IllegalArgumentException
```
    从一个时间标度中的位置构建实例。
    
    参数：
    
    field - 默认使用的字段
    
    year - 年份（BC年份可能为0或负数）
    
    month - 月份枚举
    
    day - 日期，从1到31
    
    hour - 小时，从0到23
    
    minute - 分钟，从0到59
    
    second - 秒，从0.0到60.0（不包括）
    
    timeScale - 时间标度
    
    抛出：
    
    IllegalArgumentException - 如果给定的参数不一致（参数超出范围）
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(org.hipparchus.Field<T> field,
                         DateComponents date,
                         TimeScale timeScale)
                  throws IllegalArgumentException
```
    从一个时间标度中的位置构建实例。
    小时设置为00:00:00.000。
    
    参数:
    
    field - 默认使用的字段
    
    date - 时间标尺中的日期位置
    
    timeScale - 时间标尺
    
    抛出:
    
    IllegalArgumentException - 如果给定的参数不一致（参数超出范围）
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(org.hipparchus.Field<T> field,
                         int year,
                         int month,
                         int day,
                         TimeScale timeScale)
                  throws IllegalArgumentException
```
    从时间标尺中的位置构建一个实例。
    小时设置为00:00:00.000。
    
    参数:
    
    field - 默认使用的字段
    
    year - 年份（可以是0或负数表示公元前年份）
    
    month - 月份从1到12
    
    day - 日期从1到31
    
    timeScale - 时间标尺
    
    抛出:
    
    IllegalArgumentException - 如果给定的参数不一致（参数超出范围）
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(org.hipparchus.Field<T> field,
                         int year,
                         Month month,
                         int day,
                         TimeScale timeScale)
                  throws IllegalArgumentException
```
    从时间标尺中的位置构建一个实例。
    小时设置为00:00:00.000。
    
    参数:
    
    field - 默认使用的字段
    
    year - 年份（可以是0或负数表示公元前年份）
    
    month - 月份枚举
    
    day - 日期从1到31
    
    timeScale - 时间标尺
    
    抛出:
    
    IllegalArgumentException - 如果给定的参数不一致（参数超出范围）
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(org.hipparchus.Field<T> field,
                         Date location,
                         TimeScale timeScale)
```
    从时间标尺中的位置构建一个实例。
    
    参数:
    
    field - 默认使用的字段
    
    location - 时间标尺中的位置
    
    timeScale - 时间标尺
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(org.hipparchus.Field<T> field,
                         Instant instant,
                         TimeScale timeScale)
```
    从瞬时和时间标尺中构建一个实例。
    
    参数:
    
    field - 默认使用的字段
    
    instant - 时间标尺中的瞬时
    
    timeScale - 时间标尺
    
    自版本:
    
    12.0
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(FieldAbsoluteDate<T> since,
                         double elapsedDuration)
```
    从一个瞬时到另一个瞬时的经过时间构建一个实例。
    重要说明：经过时间不是两个时间标尺读数之间的差异。
    
    参数:
    
    since - 测量持续时间的起始瞬时
    
    elapsedDuration - 从since瞬时开始的物理经过时间，按照常规时间标尺测量
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(AbsoluteDate since,
                         T elapsedDuration)
```
    从一个瞬时到另一个瞬时的经过时间构建一个实例。
    重要说明：经过时间不是两个时间标尺读数之间的差异。
    
    参数:
    
    since - 测量持续时间的起始瞬时
    
    elapsedDuration - 从since瞬时开始的物理经过时间，按照常规时间标尺测量
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(FieldAbsoluteDate<T> reference,
                         double apparentOffset,
                         TimeScale timeScale)
```
    从相对于另一个瞬时的表观时钟偏移构建一个实例，在特定的时间标尺的视角中。
    重要说明：表观时钟偏移是两个时间标尺读数之间的差异，而不是经过时间。例如，在导致读数为2005-12-31T23:59:59和2006-01-01T00:00:00的两个瞬时之间的表观时钟偏移在UTC时间标尺中为1秒，但经过时间为2秒，因为在该时间标尺中在2005年底引入了一个闰秒。
    
    此构造函数是offsetFrom(FieldAbsoluteDate, TimeScale)方法的反向操作。
    
    参数:
    
    reference - 参考瞬时
    
    apparentOffset - 相对于参考瞬时的表观时钟偏移（在指定时间标尺中两个读数之间的差异）
    
    timeScale - 定义偏移的时间标尺
    
    另请参阅:
    
    offsetFrom(FieldAbsoluteDate, TimeScale)
- Method Detail
  - parseCCSDSUnsegmentedTimeCode
```
@DefaultDataContext
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> parseCCSDSUnsegmentedTimeCode(org.hipparchus.Field<T> field,
                                                                                                                                        byte preambleField1,
                                                                                                                                        byte preambleField2,
                                                                                                                                        byte[] timeField,
                                                                                                                                        FieldAbsoluteDate<T> agencyDefinedEpoch)
```
    从CCSDS非分段时间代码（CUC）构建一个实例。
    CCSDS非分段时间代码定义在蓝皮书中：CCSDS时间代码格式（CCSDS 301.0-B-4），2010年11月出版
    
    如果要解析的日期使用标准的第3版（2002年出版的CCSDS 301.0-B-3）格式，或者如果标准的第4版中引入的前导字段扩展未被使用，则preambleField2参数可以设置为0。
    
    如果使用CCSDS纪元，则此方法使用默认数据上下文。
    
    类型参数:
    
    T - 字段元素的类型
    
    参数:
    
    field - 组件的字段
    
    preambleField1 - 指定格式的字段的第一个字节，通常不在数据接口中传输，因为对于给定的数据接口是恒定的
    
    preambleField2 - 指定格式的字段的第二个字节（2010年CCSDS标准修订版4中添加），通常不在数据接口中传输，因为对于给定的数据接口是恒定的（如果在preambleField1中未标记存在，则忽略该值）
    
    timeField - 包含时间代码的字节数组
    
    agencyDefinedEpoch - 参考纪元，如果前导字段指定使用CCSDS参考纪元（因此在这种情况下可能为null）
    
    返回:
    
    对应于指定日期的实例
    
    另请参阅:
    
    parseCCSDSUnsegmentedTimeCode(Field, byte, byte, byte[], FieldAbsoluteDate, FieldAbsoluteDate)
  - parseCCSDSUnsegmentedTimeCode
```
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> parseCCSDSUnsegmentedTimeCode(org.hipparchus.Field<T> field,
                                                                                                                    byte preambleField1,
                                                                                                                    byte preambleField2,
                                                                                                                    byte[] timeField,
                                                                                                                    FieldAbsoluteDate<T> agencyDefinedEpoch,
                                                                                                                    FieldAbsoluteDate<T> ccsdsEpoch)
```
    从CCSDS非分段时间代码（CUC）构建一个实例。
    CCSDS非分段时间代码定义在蓝皮书中：CCSDS时间代码格式（CCSDS 301.0-B-4），2010年11月出版
    
    如果要解析的日期使用标准的第3版（2002年出版的CCSDS 301.0-B-3）格式，或者如果标准的第4版中引入的前导字段扩展未被使用，则preambleField2参数可以设置为0。
    
    类型参数:
    
    T - 字段元素的类型
    
    参数:
    
    field - 组件的字段
    
    preambleField1 - 指定格式的字段的第一个字节，通常不在数据接口中传输，因为对于给定的数据接口是恒定的
    
    preambleField2 - 指定格式的字段的第二个字节（2010年CCSDS标准修订版4中添加），通常不在数据接口中传输，因为对于给定的数据接口是恒定的（如果在preambleField1中未标记存在，则忽略该值）
    
    timeField - 包含时间代码的字节数组
    
    agencyDefinedEpoch - 参考纪元，如果前导字段指定使用CCSDS参考纪元，则忽略（在这种情况下可能为null）
    
    ccsdsEpoch - 参考纪元，如果前导字段指定使用机构纪元，则忽略
    
    返回:
    
    对应于指定日期的实例
    
    自版本:
    
    10.1
  - parseCCSDSDaySegmentedTimeCode
```
@DefaultDataContext
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> parseCCSDSDaySegmentedTimeCode(org.hipparchus.Field<T> field,
                                                                                                                                         byte preambleField,
                                                                                                                                         byte[] timeField,
                                                                                                                                         DateComponents agencyDefinedEpoch)
```
    从CCSDS分段时间代码（CDS）构建一个实例。
    CCSDS分段时间代码定义在蓝皮书中：CCSDS时间代码格式（CCSDS 301.0-B-4），2010年11月出版
    
    如果使用CCSDS纪元，则此方法使用默认数据上下文。
    
    类型参数:
    
    T - 字段元素的类型
    
    参数:
    
    field - 组件的字段
    
    preambleField - 指定格式的字段，通常不在数据接口中传输，因为对于给定的数据接口是恒定的
    
    timeField - 包含时间码的字节数组
    
    agencyDefinedEpoch - 参考时期，如果前导字段指定使用CCSDS参考时期（因此在这种情况下可能为null）
    
    返回:
    
    对应于指定日期的实例
    
    另请参阅:
    
    parseCCSDSDaySegmentedTimeCode(Field, byte, byte[], DateComponents, TimeScale)
  - parseCCSDSDaySegmentedTimeCode
```
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> parseCCSDSDaySegmentedTimeCode(org.hipparchus.Field<T> field,
                                                                                                                     byte preambleField,
                                                                                                                     byte[] timeField,
                                                                                                                     DateComponents agencyDefinedEpoch,
                                                                                                                     TimeScale utc)
```
    从CCSDS日分段时间码（CDS）构建实例。
    CCSDS日分段时间码定义在蓝皮书中：CCSDS时间码格式（CCSDS 301.0-B-4），2010年11月出版
    
    类型参数:
    
    T - 字段元素的类型
    
    参数:
    
    field - 组件的字段
    
    preambleField - 指定格式的字段，通常不在数据接口中传输，因为对于给定的数据接口是恒定的
    
    timeField - 包含时间码的字节数组
    
    agencyDefinedEpoch - 参考时期，如果前导字段指定使用CCSDS参考时期（因此在这种情况下可能为null）
    
    utc - 用于计算日期和时间分量的时间标度。
    
    返回:
    
    对应于指定日期的实例
    
    自版本:
    
    10.1
  - parseCCSDSCalendarSegmentedTimeCode
```
@DefaultDataContext
public FieldAbsoluteDate<T> parseCCSDSCalendarSegmentedTimeCode(byte preambleField,
                                                                                    byte[] timeField)
```
    从CCSDS日历分段时间码（CCS）构建实例。
    CCSDS日历分段时间码定义在蓝皮书中：CCSDS时间码格式（CCSDS 301.0-B-4），2010年11月出版
    
    此方法使用默认数据上下文。
    
    参数:
    
    preambleField - 指定格式的字段，通常不在数据接口中传输，因为对于给定的数据接口是恒定的
    
    timeField - 包含时间码的字节数组
    
    返回:
    
    对应于指定日期的实例
    
    另请参阅:
    
    parseCCSDSCalendarSegmentedTimeCode(byte, byte[], TimeScale)
  - parseCCSDSCalendarSegmentedTimeCode
```
public FieldAbsoluteDate<T> parseCCSDSCalendarSegmentedTimeCode(byte preambleField,
                                                                byte[] timeField,
                                                                TimeScale utc)
```
    从CCSDS日历分段时间码（CCS）构建实例。
    CCSDS日历分段时间码定义在蓝皮书中：CCSDS时间码格式（CCSDS 301.0-B-4），2010年11月出版
    
    参数:
    
    preambleField - 指定格式的字段，通常不在数据接口中传输，因为对于给定的数据接口是恒定的
    
    timeField - 包含时间码的字节数组
    
    utc - 用于计算日期和时间分量的时间标度。
    
    返回:
    
    对应于指定日期的实例
    
    自版本:
    
    10.1
  - createJDDate
```
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> createJDDate(int jd,
                                                                                                   T secondsSinceNoon,
                                                                                                   TimeScale timeScale)
```
    构建对应于儒略日日期的实例。
    
    类型参数:
    
    T - 字段元素的类型
    
    参数:
    
    jd - 儒略日
    
    secondsSinceNoon - 一天中的秒数（注意，儒略日从中午开始，因此0.0是中午）
    
    timeScale - 定义一天中秒数的时间标度
    
    返回:
    
    一个新的实例
  - createMJDDate
```
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> createMJDDate(int mjd,
                                                                                                    T secondsInDay,
                                                                                                    TimeScale timeScale)
```
    构建对应于修正儒略日日期的实例。
    
    类型参数:
    
    T - 字段元素的类型
    
    参数:
    
    mjd - 修正儒略日
    
    secondsInDay - 一天中的秒数
    
    timeScale - 定义一天中秒数的时间标度
    
    返回:
    
    一个新的实例
  - createGPSDate
```
@DefaultDataContext
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> createGPSDate(int weekNumber,
                                                                                                                        T milliInWeek)
```
    构建对应于GPS日期的实例。
    此方法使用默认数据上下文。
    
    GPS日期以从GPS纪元开始的周数和自周开始以来的毫秒数提供。
    
    类型参数:
    
    T - 字段元素的类型
    
    参数:
    
    weekNumber - 自GPS纪元以来的周数
    
    milliInWeek - 自周开始以来的毫秒数
    
    返回:
    
    一个新的实例
    
    另请参阅:
    
    createGPSDate(int, CalculusFieldElement, TimeScale)
  - createGPSDate
```
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> createGPSDate(int weekNumber,
                                                                                                    T milliInWeek,
                                                                                                    TimeScale gps)
```
    构建对应于GPS日期的实例。
    GPS日期以从GPS纪元开始的周数和自周开始以来的毫秒数提供。
    
    类型参数:
    
    T - 字段元素的类型
    
    参数:
    
    weekNumber - 自GPS纪元以来的周数
    
    milliInWeek - 自周开始以来的毫秒数
    
    gps - GPS时间标度。
    
    返回:
    
    一个新的实例
    
    自版本:
    
    10.1
  - createJulianEpoch
```
@DefaultDataContext
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> createJulianEpoch(T julianEpoch)
```
    构建对应于儒略纪元（JE）的实例。
    根据Lieske的论文：基于IAU（1976）天文常数系统的岁差矩阵，天文学与天体物理学，第73卷，第3号，1979年3月，第282-284页，儒略纪元与儒略历日期关系如下：
```
JE = 2000.0 + (JED - 2451545.0) / 365.25
```
    此方法反转上述公式，并从儒略纪元计算FieldAbsoluteDate<T>。
    
    此方法使用默认数据上下文。
    类型参数:
    
    T - 字段元素的类型
    
    参数:
    
    julianEpoch - 儒略纪元，如2000.0用于定义经典参考J2000.0
    
    返回:
    
    一个新的实例
    
    另请参阅:
    
    getJ2000Epoch(Field), createBesselianEpoch(CalculusFieldElement), createJulianEpoch(CalculusFieldElement, TimeScales)
  - createJulianEpoch
```
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> createJulianEpoch(T julianEpoch,
                                                                                                        TimeScales timeScales)
```
    构建对应于儒略纪元（JE）的实例。
    根据Lieske的论文：基于IAU（1976）天文常数系统的岁差矩阵，天文学与天体物理学，第73卷，第3号，1979年3月，第282-284页，儒略纪元与儒略历日期关系如下：
```
JE = 2000.0 + (JED - 2451545.0) / 365.25
```
    此方法反转上述公式，并从儒略纪元计算FieldAbsoluteDate<T>。
    类型参数:
    
    T - 字段元素的类型
    
    参数:
    
    julianEpoch - 儒略纪元，如2000.0用于定义经典参考J2000.0
    
    timeScales - 在计算中使用。
    
    返回:
    
    一个新的实例
    
    自版本:
    
    10.1
    
    另请参阅:
    
    getJ2000Epoch(Field), createBesselianEpoch(CalculusFieldElement), TimeScales.createJulianEpoch(double)
  - createBesselianEpoch
```
@DefaultDataContext
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> createBesselianEpoch(T besselianEpoch)
```
    构建与贝塞尔时代（BE）对应的实例。
    根据Lieske的论文：基于IAU（1976）天文常数体系的岁差矩阵，天文学与天体物理学，第73卷，第3期，1979年3月，第282-284页，贝塞尔时代与儒略历日期的关系如下：
```
 BE = 1900.0 + (JED - 2415020.31352) / 365.242198781
 
```
    此方法反转上述公式，并从贝塞尔时代计算出一个FieldAbsoluteDate<T>。
    
    此方法使用默认数据上下文。
    类型参数：
    
    T - 字段元素的类型
    
    参数：
    
    besselianEpoch - 贝塞尔时代，如1950年用于定义经典参考B1950.0
    
    返回：
    
    一个新的实例
    
    另请参阅：
    
    createJulianEpoch(CalculusFieldElement)，createBesselianEpoch(CalculusFieldElement, TimeScales)
  - createBesselianEpoch
```
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> createBesselianEpoch(T besselianEpoch,
                                                                                                           TimeScales timeScales)
```
    构建与贝塞尔时代（BE）对应的实例。
    根据Lieske的论文：基于IAU（1976）天文常数体系的岁差矩阵，天文学与天体物理学，第73卷，第3期，1979年3月，第282-284页，贝塞尔时代与儒略历日期的关系如下：
```
 BE = 1900.0 + (JED - 2415020.31352) / 365.242198781
 
```
    此方法反转上述公式，并从贝塞尔时代计算出一个FieldAbsoluteDate<T>。
    类型参数：
    
    T - 字段元素的类型
    
    参数：
    
    besselianEpoch - 贝塞尔时代，如1950年用于定义经典参考B1950.0
    
    timeScales - 用于计算。
    
    返回：
    
    一个新的实例
    
    自：
    
    10.1
    
    另请参阅：
    
    createJulianEpoch(CalculusFieldElement)，TimeScales.createBesselianEpoch(double)
  - getJulianEpoch
```
@DefaultDataContext
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> getJulianEpoch(org.hipparchus.Field<T> field)
```
    儒略日期的参考时代：-4712-01-01T12:00:00地球时间。
    java.util.Date和DateComponents类遵循天文约定，将年份0视为-1年和+1年之间，因此此参考日期位于-4712年而不是其他遵循不同约定的文档或程序中的-4713年（例如convcal实用程序）。
    
    此方法使用默认数据上下文。
    
    类型参数：
    
    T - 字段元素的类型
    
    参数：
    
    field - 组件的字段
    
    返回：
    
    儒略日期的参考时代作为FieldAbsoluteDate
    
    另请参阅：
    
    AbsoluteDate.JULIAN_EPOCH，TimeScales.getJulianEpoch()
  - getModifiedJulianEpoch
```
@DefaultDataContext
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> getModifiedJulianEpoch(org.hipparchus.Field<T> field)
```
    修改儒略日期的参考时代：1858-11-17T00:00:00地球时间。
    此方法使用默认数据上下文。
    
    类型参数：
    
    T - 字段元素的类型
    
    参数：
    
    field - 组件的字段
    
    返回：
    
    修改儒略日期的参考时代作为FieldAbsoluteDate
    
    另请参阅：
    
    AbsoluteDate.MODIFIED_JULIAN_EPOCH，TimeScales.getModifiedJulianEpoch()
  - getFiftiesEpoch
```
@DefaultDataContext
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> getFiftiesEpoch(org.hipparchus.Field<T> field)
```
    1950年日期的参考时代：1950-01-01T00:00:00地球时间。
    此方法使用默认数据上下文。
    
    类型参数：
    
    T - 字段元素的类型
    
    参数：
    
    field - 组件的字段
    
    返回：
    
    1950年日期的参考时代作为FieldAbsoluteDate
    
    另请参阅：
    
    AbsoluteDate.FIFTIES_EPOCH，TimeScales.getFiftiesEpoch()
  - getCCSDSEpoch
```
@DefaultDataContext
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> getCCSDSEpoch(org.hipparchus.Field<T> field)
```
    CCSDS时间代码格式（CCSDS 301.0-B-4）的参考时代：
    此方法使用默认数据上下文。1958-01-01T00:00:00国际原子时（非协调世界时）。
    
    类型参数：
    
    T - 字段元素的类型
    
    参数：
    
    field - 组件的字段
    
    返回：
    
    CCSDS时间代码格式的参考时代作为FieldAbsoluteDate
    
    另请参阅：
    
    AbsoluteDate.CCSDS_EPOCH，TimeScales.getCcsdsEpoch()
  - getGalileoEpoch
```
@DefaultDataContext
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> getGalileoEpoch(org.hipparchus.Field<T> field)
```
    伽利略系统时间的参考时代：1999-08-22T00:00:00协调世界时。
    此方法使用默认数据上下文。
    
    类型参数：
    
    T - 字段元素的类型
    
    参数：
    
    field - 组件的字段
    
    返回：
    
    伽利略系统时间的参考时代作为FieldAbsoluteDate
    
    另请参阅：
    
    AbsoluteDate.GALILEO_EPOCH，TimeScales.getGalileoEpoch()
  - getGPSEpoch
```
@DefaultDataContext
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> getGPSEpoch(org.hipparchus.Field<T> field)
```
    GPS周的参考时代：1980-01-06T00:00:00 GPS时间。
    此方法使用默认数据上下文。
    
    类型参数：
    
    T - 字段元素的类型
    
    参数：
    
    field - 组件的字段
    
    返回：
    
    GPS周的参考时代作为FieldAbsoluteDate
    
    另请参阅：
    
    AbsoluteDate.GPS_EPOCH，TimeScales.getGpsEpoch()
  - getJ2000Epoch
```
@DefaultDataContext
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> getJ2000Epoch(org.hipparchus.Field<T> field)
```
    J2000.0参考时代：2000-01-01T12:00:00地球时间（非协调世界时）。
    此方法使用默认数据上下文。
    
    类型参数：
    
    T - 字段元素的类型
    
    参数：
    
    field - 组件的字段
    
    返回：
    
    J2000.0参考时代作为FieldAbsoluteDate
    
    另请参阅：
    
    createJulianEpoch(CalculusFieldElement)，AbsoluteDate.J2000_EPOCH，TimeScales.getJ2000Epoch()
  - getJavaEpoch
```
@DefaultDataContext
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> getJavaEpoch(org.hipparchus.Field<T> field)
```
    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秒
    
    类型参数：
    
    T - 字段元素的类型
    
    参数：
    
    field - 组件的字段
    
    返回：
    
    Java参考时代作为FieldAbsoluteDate
    
    另请参阅：
    
    AbsoluteDate.JAVA_EPOCH，TimeScales.getJavaEpoch()
  - getPastInfinity
```
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> getPastInfinity(org.hipparchus.Field<T> field)
```
    过去无限远处的虚拟日期。
    
    类型参数:
    
    T - 字段元素的类型
    
    参数:
    
    field - 组件的字段
    
    返回:
    
    过去方向上的无穷远虚拟日期作为FieldAbsoluteDate
    
    另请参阅:
    
    AbsoluteDate.PAST_INFINITY, TimeScales.getPastInfinity()
  - getFutureInfinity
```
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> getFutureInfinity(org.hipparchus.Field<T> field)
```
    未来方向上的无穷远虚拟日期。
    
    类型参数:
    
    T - 字段元素的类型
    
    参数:
    
    field - 组件的字段
    
    返回:
    
    未来方向上的无穷远虚拟日期作为FieldAbsoluteDate
    
    另请参阅:
    
    AbsoluteDate.FUTURE_INFINITY, TimeScales.getFutureInfinity()
  - getArbitraryEpoch
```
public static <T extends org.hipparchus.CalculusFieldElement<T>> FieldAbsoluteDate<T> getArbitraryEpoch(org.hipparchus.Field<T> field)
```
    获取任意日期。在需要非空日期但其值无关紧要时很有用。
    
    类型参数:
    
    T - 字段元素的类型
    
    参数:
    
    field - 组件的字段
    
    返回:
    
    一个任意日期。
  - shiftedBy
```
public FieldAbsoluteDate<T> shiftedBy(T dt)
```
    获取时间偏移日期。
    调用此方法等同于调用new FieldAbsoluteDate<>(this, dt)。
    
    接口中指定的:
    
    shiftedBy 在接口 FieldTimeShiftable<FieldAbsoluteDate<T extends org.hipparchus.CalculusFieldElement<T>>,T extends org.hipparchus.CalculusFieldElement<T>>
    
    参数:
    
    dt - 以秒为单位的时间偏移
    
    返回:
    
    一个新的日期，相对于实例进行了偏移（实例是不可变的）
    
    另请参阅:
    
    FieldPVCoordinates.shiftedBy(double), FieldAttitude.shiftedBy(double), TimeShiftable.shiftedBy(double), FieldSpacecraftState.shiftedBy(double)
  - durationFrom
```
public T durationFrom(FieldAbsoluteDate<T> instant)
```
    计算两个时刻之间的物理经过时间。
    返回的持续时间是两个时刻之间物理上经过的秒数，在与地球表面的常规时间尺度上测量（即TAI尺度、TT尺度或GPS尺度）。这是唯一提供具有物理意义的持续时间的方法。
    
    此方法与使用第二个参数设置为上述任一常规尺度之一的offsetFrom(FieldAbsoluteDate, TimeScale)方法给出相同的结果（计算量更少）。
    
    此方法是FieldAbsoluteDate(FieldAbsoluteDate, double)构造函数的反向方法。
    
    参数:
    
    instant - 要从实例中减去的时刻
    
    返回:
    
    两个时刻之间的偏移秒数（如果实例在参数之后则为正）
    
    另请参阅:
    
    offsetFrom(FieldAbsoluteDate, TimeScale), FieldAbsoluteDate(FieldAbsoluteDate, double)
  - durationFrom
```
public T durationFrom(AbsoluteDate instant)
```
    计算两个时刻之间的物理经过时间。
    返回的持续时间是两个时刻之间物理上经过的秒数，在与地球表面的常规时间尺度上测量（即TAI尺度、TT尺度或GPS尺度）。这是唯一提供具有物理意义的持续时间的方法。
    
    此方法与使用第二个参数设置为上述任一常规尺度之一的offsetFrom(FieldAbsoluteDate, TimeScale)方法给出相同的结果（计算量更少）。
    
    此方法是FieldAbsoluteDate(FieldAbsoluteDate, double)构造函数的反向方法。
    
    参数:
    
    instant - 要从实例中减去的时刻
    
    返回:
    
    两个时刻之间的偏移秒数（如果实例在参数之后则为正）
    
    另请参阅:
    
    offsetFrom(FieldAbsoluteDate, TimeScale), FieldAbsoluteDate(FieldAbsoluteDate, double)
  - offsetFrom
```
public T offsetFrom(FieldAbsoluteDate<T> instant,
                    TimeScale timeScale)
```
    计算两个时刻之间的表观时钟偏移在特定时间尺度的视角中。
    偏移是在给定时间尺度中计算的秒数，表示两个时刻的位置之间的秒数，消除了所有时间尺度的不规则性（即认为所有天都恰好是86400秒长）。如果时间尺度不规则，此方法将给出一个可能没有物理意义的结果。例如，自2005年底引入闰秒以来，2005-12-31T23:59:59和2006-01-01T00:00:00之间的表观偏移是1秒，但由durationFrom(FieldAbsoluteDate)方法返回的相应时间间隔的物理持续时间是2秒。
    
    此方法是FieldAbsoluteDate(FieldAbsoluteDate, double, TimeScale)构造函数的反向方法。
    
    参数:
    
    instant - 要从实例中减去的时刻
    
    timeScale - 应计算偏移的时间尺度
    
    返回:
    
    两个时刻之间的表观时钟偏移秒数（如果实例在参数之后则为正）
    
    另请参阅:
    
    durationFrom(FieldAbsoluteDate), FieldAbsoluteDate(FieldAbsoluteDate, double, TimeScale)
  - timeScalesOffset
```
public T 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为负）
    
    返回：
    
    日期/时间组件
    
    另请参阅：
    
    getComponents(int, TimeScale)
  - getComponents
```
public DateTimeComponents getComponents(int minutesFromUTC,
                                        TimeScale utc)
```
    将实例拆分为本地时间的日期/时间组件。
    
    参数：
    
    minutesFromUTC - 与UTC的偏移量（东UTC为正，西UTC为负）
    
    utc - 用于计算日期和时间组件的时间刻度。
    
    返回：
    
    日期/时间组件
    
    自版本：
    
    10.1
  - getDate
```
public FieldAbsoluteDate<T> getDate()
```
    获取日期。
    
    指定者：
    
    getDate 在接口 FieldTimeStamped<T extends org.hipparchus.CalculusFieldElement<T>>
    
    返回：
    
    附加到对象的日期
  - getField
```
public org.hipparchus.Field<T> getField()
```
    获取字段。
    
    返回：
    
    字段实例。
  - getComponents
```
@DefaultDataContext
public DateTimeComponents getComponents(TimeZone timeZone)
```
    将实例拆分为时区的日期/时间组件。
    此方法使用默认数据上下文。
    
    参数：
    
    timeZone - 时区
    
    返回：
    
    日期/时间组件
    
    另请参阅：
    
    getComponents(TimeZone, TimeScale)
  - getComponents
```
public DateTimeComponents getComponents(TimeZone timeZone,
                                        TimeScale utc)
```
    将实例拆分为时区的日期/时间组件。
    
    参数：
    
    timeZone - 时区
    
    utc - 用于计算日期和时间组件的时间刻度。
    
    返回：
    
    日期/时间组件
    
    自版本：
    
    10.1
  - compareTo
```
public int compareTo(FieldAbsoluteDate<T> date)
```
    将实例与另一个日期进行比较。
    
    指定者：
    
    compareTo 在接口 Comparable<FieldAbsoluteDate<T extends org.hipparchus.CalculusFieldElement<T>>>
    
    参数：
    
    date - 要将实例与之比较的其他日期
    
    返回：
    
    如果此日期在指定日期之前、同时或之后，则为负整数、零或正整数。
  - equals
```
public boolean equals(Object date)
```
    检查实例是否表示与另一个实例相同的时间。
    
    覆盖：
    
    equals 在类 Object
    
    参数：
    
    date - 其他日期
    
    返回：
    
    如果实例和其他日期引用相同的时刻，则为true
  - isEqualTo
```
public boolean isEqualTo(FieldTimeStamped<T> other)
```
    检查实例是否表示与另一个实例相同的时间。
    
    参数：
    
    other - 要将此日期与之比较的时刻
    
    返回：
    
    如果实例和参数引用相同的时刻，则为true
    
    自版本：
    
    10.1
    
    另请参阅：
    
    isCloseTo(FieldTimeStamped, double)
  - isCloseTo
```
public boolean isCloseTo(FieldTimeStamped<T> other,
                         double tolerance)
```
    检查实例时间是否接近另一个时间。
    
    参数：
    
    other - 要将此日期与之比较的时刻
    
    tolerance - 两个时刻被认为彼此接近的间隔，以秒为单位
    
    返回：
    
    如果实例与参数之间的持续时间严格低于容差，则为true
    
    自版本：
    
    10.1
    
    另请参阅：
    
    isEqualTo(FieldTimeStamped)
  - isBefore
```
public boolean isBefore(FieldTimeStamped<T> other)
```
    检查实例是否表示严格早于另一个时间。
    
    参数：
    
    other - 要将此日期与之比较的时刻
    
    返回：
    
    如果实例在时间顺序上严格在参数之前，则为true
    
    自版本：
    
    10.1
    
    另请参阅：
    
    isBeforeOrEqualTo(FieldTimeStamped)
  - isAfter
```
public boolean isAfter(FieldTimeStamped<T> other)
```
    检查实例是否表示严格晚于另一个时间。
    
    参数：
    
    other - 要将此日期与之比较的时刻
    
    返回：
    
    如果实例在时间顺序上严格在参数之后，则为true
    
    自版本：
    
    10.1
    
    另请参阅：
    
    isAfterOrEqualTo(FieldTimeStamped)
  - isBeforeOrEqualTo
```
public boolean isBeforeOrEqualTo(FieldTimeStamped<T> other)
```
    检查实例时间是否早于或等于另一个时间。
    
    参数：
    
    other - 要将此日期与之比较的时刻
    
    返回：
    
    如果实例在时间顺序上早于（或等于）参数，则为true
    
    自版本：
    
    10.1
    
    另请参阅：
    
    isBefore(FieldTimeStamped)
  - isAfterOrEqualTo
```
public boolean isAfterOrEqualTo(FieldTimeStamped<T> other)
```
    检查实例时间是否晚于或等于另一个时间。
    
    参数：
    
    other - 要将此日期与之比较的时刻
    
    返回：
    
    如果实例在时间顺序上晚于（或等于）参数，则为true
    
    自版本：
    
    10.1
    
    另请参阅：
    
    isAfterOrEqualTo(FieldTimeStamped)
  - isBetween
```
public boolean isBetween(FieldTimeStamped<T> boundary,
                         FieldTimeStamped<T> otherBoundary)
```
    检查实例时间是否严格介于表示时间跨度边界的两个其他时间之间。两个边界可以以任何顺序提供：换句话说，boundary表示的时间早于或晚于otherBoundary都不会改变此方法的结果。
    
    参数：
    
    boundary - 时间跨度的一端
    
    otherBoundary - 时间跨度的另一端
    
    返回：
    
    如果实例在时间顺序上严格介于两个参数之间，则为true
    
    自版本：
    
    10.1
    
    另请参阅：
    
    isBetweenOrEqualTo(FieldTimeStamped, FieldTimeStamped)
  - isBetweenOrEqualTo
```
public boolean isBetweenOrEqualTo(FieldTimeStamped<T> boundary,
                                  FieldTimeStamped<T> otherBoundary)
```
    检查实例是否表示严格介于表示时间跨度边界的两个其他时间之间，或等于其中一个。两个边界可以以任何顺序提供：换句话说，boundary表示的时间早于或晚于otherBoundary都不会改变此方法的结果。
    
    参数:
    
    boundary - 时间跨度的一端
    
    otherBoundary - 时间跨度的另一端
    
    返回:
    
    如果实例在这两个参数之间（或至少等于其中一个）时按时间顺序排序，则返回true
    
    自从:
    
    10.1
    
    另请参阅:
    
    isBetween(FieldTimeStamped, FieldTimeStamped)
  - hashCode
```
public int hashCode()
```
    获取此日期的哈希码。
    
    覆盖:
    
    hashCode 在类 Object中
    
    返回:
    
    哈希码
  - toString
```
@DefaultDataContext
public String toString()
```
    获取实例位置的字符串表示，秒值精度高达16位。
    由于此方法用于异常消息和错误处理，因此会尽一切努力返回实例的某种表示。如果默认数据上下文中提供了UTC，则将使用UTC格式化字符串。如果没有，则使用TAI。最后，如果前面的尝试失败，此方法将退回将此类的内部表示转换为字符串。
    
    此方法使用默认数据上下文。
    
    覆盖:
    
    toString 在类 Object中
    
    返回:
    
    实例的字符串表示，如果默认数据上下文中提供了UTC，则为ISO-8601格式。
    
    另请参阅:
    
    AbsoluteDate.toString(), toString(TimeScale), DateTimeComponents.toString(int, int)
  - toString
```
public String toString(TimeScale timeScale)
```
    获取实例位置的字符串表示，采用ISO-8601格式，不带UTC偏移量，秒值精度高达16位。
    
    参数:
    
    timeScale - 要使用的时间标度
    
    返回:
    
    实例的字符串表示。
    
    另请参阅:
    
    DateTimeComponents.toString(int, int)
  - toString
```
@DefaultDataContext
public String toString(int minutesFromUTC)
```
    获取本地时间的实例位置的字符串表示。
    此方法使用默认数据上下文。
    
    参数:
    
    minutesFromUTC - 与UTC的偏移量（东UTC为正，西UTC为负）。
    
    返回:
    
    实例的字符串表示，ISO-8601格式，毫秒精度
    
    另请参阅:
    
    toString(int, TimeScale)
  - toString
```
public String toString(int minutesFromUTC,
                       TimeScale utc)
```
    获取本地时间的实例位置的字符串表示。
    
    参数:
    
    minutesFromUTC - 与UTC的偏移量（东UTC为正，西UTC为负）。
    
    utc - 用于计算日期和时间组件的时间标度。
    
    返回:
    
    实例的字符串表示，ISO-8601格式，毫秒精度
    
    自从:
    
    10.1
  - toString
```
@DefaultDataContext
public String toString(TimeZone timeZone)
```
    获取时区的实例位置的字符串表示。
    此方法使用默认数据上下文。
    
    参数:
    
    timeZone - 时区
    
    返回:
    
    实例的字符串表示，ISO-8601格式，毫秒精度
    
    另请参阅:
    
    toString(TimeZone, TimeScale)
  - toString
```
public String toString(TimeZone timeZone,
                       TimeScale utc)
```
    获取时区的实例位置的字符串表示。
    
    参数:
    
    timeZone - 时区
    
    utc - 用于计算日期和时间组件的时间标度。
    
    返回:
    
    实例的字符串表示，ISO-8601格式，毫秒精度
    
    自从:
    
    10.1
  - shiftedBy
```
public FieldAbsoluteDate<T> shiftedBy(double dt)
```
    获取一个时间偏移的日期。
    调用此方法等效于调用new FieldAbsoluteDate(this, dt)。
    
    指定者:
    
    shiftedBy 在接口 TimeShiftable<FieldAbsoluteDate<T extends org.hipparchus.CalculusFieldElement<T>>>
    
    参数:
    
    dt - 秒数的时间偏移
    
    返回:
    
    一个新的日期，相对于实例进行了偏移（实例是不可变的）
    
    另请参阅:
    
    FieldPVCoordinates.shiftedBy(double), FieldAttitude.shiftedBy(double), TimeShiftable.shiftedBy(double), FieldSpacecraftState.shiftedBy(double)
  - toAbsoluteDate
```
public AbsoluteDate toAbsoluteDate()
```
    将FieldAbsoluteDate转换为AbsoluteDate。
    
    返回:
    
    FieldObject的AbsoluteDate
  - hasZeroField
```
public boolean hasZeroField()
```
    检查Field是否在语义上等于零。
    使用FieldElement.isZero()
    
    返回:
    
    如果Field在语义上等于零，则返回true
    
    自从:
    
    12.0

Class FieldAbsoluteDate<T extends org.hipparchus.CalculusFieldElement<T>>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.orekit.time.FieldTimeStamped

Constructor Detail

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

Method Detail

parseCCSDSUnsegmentedTimeCode

parseCCSDSUnsegmentedTimeCode

parseCCSDSDaySegmentedTimeCode

parseCCSDSDaySegmentedTimeCode

parseCCSDSCalendarSegmentedTimeCode

parseCCSDSCalendarSegmentedTimeCode

createJDDate

createMJDDate

createGPSDate

createGPSDate

createJulianEpoch

createJulianEpoch

createBesselianEpoch

createBesselianEpoch

getJulianEpoch

getModifiedJulianEpoch

getFiftiesEpoch

getCCSDSEpoch

getGalileoEpoch

getGPSEpoch

getJ2000Epoch

getJavaEpoch

getPastInfinity

getFutureInfinity

getArbitraryEpoch

shiftedBy

durationFrom

durationFrom

offsetFrom

timeScalesOffset

toDate

getComponents

getComponents

getComponents

getDate

getField

getComponents

getComponents

compareTo

equals

isEqualTo

isCloseTo

isBefore

isAfter

isBeforeOrEqualTo

isAfterOrEqualTo

isBetween

isBetweenOrEqualTo

hashCode

toString

toString

toString

toString

toString

toString

shiftedBy

toAbsoluteDate