OffsetTime (Java Platform SE 8 )

java.lang.Object
- java.time.OffsetTime

All Implemented Interfaces:

Serializable， Comparable < OffsetTime >， Temporal， TemporalAccessor， TemporalAdjuster
```
public final class OffsetTime
extends Object
implements Temporal, TemporalAdjuster, Comparable<OffsetTime>, Serializable
```
与UTC偏移量/格林尼治在ISO-8601日历系统的时间，如 10:15:30+01:00。
OffsetTime是不变的日期时间对象代表一个时间，往往被视为小时分钟秒偏移。这类商店所有的时间字段，一个精确的时间，以及一个带偏移。例如，值“13:45.30.123456789 +日期”可以存储在一个OffsetTime。

这是一个value-based类；利用身份敏感的操作（包括引用相等（==），身份的哈希代码，或同步）的实例OffsetTime可能有不可预知的结果应该是可以避免的。的equals法进行比较。

实现要求：

这个类是不可变的和线程安全的。

从以下版本开始：

一点八

另请参见：

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static OffsetTime`	`MAX` 所支持的最大 `OffsetTime`，“23:59:59. 999999999 -18:00”。
`static OffsetTime`	`MIN` 最小支持 `OffsetTime`，' 00:00:00 + 18:00”。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	Method and Description
`Temporal`	`adjustInto(Temporal temporal)` 调整指定的时间对象，以具有相同的偏移和时间为这个对象。
`OffsetDateTime`	`atDate(LocalDate date)` 结合时间与日期创建一个 `OffsetDateTime`。
`int`	`compareTo(OffsetTime other)` 比较这 `OffsetTime`到另一个时间。
`boolean`	`equals(Object obj)` 检查这个时间是否等于另一个时间。
`String`	`format(DateTimeFormatter formatter)` 格式时使用指定的格式化程序。
`static OffsetTime`	`from(TemporalAccessor temporal)` 获得 `OffsetTime`实例从一个时空对象。
`int`	`get(TemporalField field)` 获取指定字段的值，从这个时间作为一个 `int`。
`int`	`getHour()` 获取天字段的时间。
`long`	`getLong(TemporalField field)` 获取指定字段的值，从这个时间作为一个 `long`。
`int`	`getMinute()` 获取小时字段的分钟。
`int`	`getNano()` 获取第二场的纳米。
`ZoneOffset`	`getOffset()` 能带偏移，如“+”01:00。
`int`	`getSecond()` 获取第二个分钟字段。
`int`	`hashCode()` 这个时候的一个哈希代码。
`boolean`	`isAfter(OffsetTime other)` 检查，如果这 `OffsetTime`瞬间之后的指定时间应用时代一个普通的日子。
`boolean`	`isBefore(OffsetTime other)` 检查，如果这 `OffsetTime`瞬间之前指定的时间运用时间一个普通的日子。
`boolean`	`isEqual(OffsetTime other)` 检查，如果这 `OffsetTime`即时等于指定的时间运用时间一个普通的日子。
`boolean`	`isSupported(TemporalField field)` 检查指定字段是否被支持。
`boolean`	`isSupported(TemporalUnit unit)` 检查指定的单位是否被支持。
`OffsetTime`	`minus(long amountToSubtract, TemporalUnit unit)` 返回此时间的副本与指定的金额减去。
`OffsetTime`	`minus(TemporalAmount amountToSubtract)` 返回此时间的副本与指定的金额减去。
`OffsetTime`	`minusHours(long hours)` 返回一份本 `OffsetTime`减去指定的时间在小时。
`OffsetTime`	`minusMinutes(long minutes)` 返回一份本 `OffsetTime`在几分钟之内减去指定的时间。
`OffsetTime`	`minusNanos(long nanos)` 返回一份本 `OffsetTime`减去指定的时间在纳秒。
`OffsetTime`	`minusSeconds(long seconds)` 返回一份本 `OffsetTime`与指定期秒减去。
`static OffsetTime`	`now()` 在默认时区中从系统时钟获取当前时间。
`static OffsetTime`	`now(Clock clock)` 从指定的时钟获取当前时间。
`static OffsetTime`	`now(ZoneId zone)` 从指定时区中的系统时钟中获得当前时间。
`static OffsetTime`	`of(int hour, int minute, int second, int nanoOfSecond, ZoneOffset offset)` 获得 `OffsetTime`实例每小时，，二和纳秒。
`static OffsetTime`	`of(LocalTime time, ZoneOffset offset)` 获得 `OffsetTime`实例从本地时间偏移。
`static OffsetTime`	`ofInstant(Instant instant, ZoneId zone)` 获得 `OffsetTime`实例从一个 `Instant`和区域ID。
`static OffsetTime`	`parse(CharSequence text)` 获得 `OffsetTime`实例从一个文本字符串，如 `10:15:30+01:00`。
`static OffsetTime`	`parse(CharSequence text, DateTimeFormatter formatter)` 获得 `OffsetTime`实例从使用特定格式的文本字符串。
`OffsetTime`	`plus(long amountToAdd, TemporalUnit unit)` 返回此时间的副本，添加指定的金额。
`OffsetTime`	`plus(TemporalAmount amountToAdd)` 返回此时间的副本，添加指定的金额。
`OffsetTime`	`plusHours(long hours)` 返回一份本 `OffsetTime`在指定时间内添加时间。
`OffsetTime`	`plusMinutes(long minutes)` 返回一份本 `OffsetTime`在几分钟之内指定期间补充。
`OffsetTime`	`plusNanos(long nanos)` 返回一份本 `OffsetTime`在纳秒指定期间补充。
`OffsetTime`	`plusSeconds(long seconds)` 返回一份本 `OffsetTime`在指定时间内增加秒。
`<R> R`	`query(TemporalQuery<R> query)` 使用指定的查询查询此时间。
`ValueRange`	`range(TemporalField field)` 获取指定字段的有效值的范围。
`LocalTime`	`toLocalTime()` 获取此日期时间的 `LocalTime`部分。
`String`	`toString()` 输出这个时间作为一个 `String`，如 `10:15:30+01:00`。
`OffsetTime`	`truncatedTo(TemporalUnit unit)` 返回一份本 `OffsetTime`与定时。
`long`	`until(Temporal endExclusive, TemporalUnit unit)` 计算时间的量，直到另一个时间在指定的单位。
`OffsetTime`	`with(TemporalAdjuster adjuster)` 返回此时间的调整副本。
`OffsetTime`	`with(TemporalField field, long newValue)` 将此时间的副本与指定的字段设置为一个新值。
`OffsetTime`	`withHour(int hour)` 返回一份本 `OffsetTime`与一个值改变。
`OffsetTime`	`withMinute(int minute)` 返回一份本 `OffsetTime`与分钟小时值改变。
`OffsetTime`	`withNano(int nanoOfSecond)` 返回一份本 `OffsetTime`与纳米二值改变。
`OffsetTime`	`withOffsetSameInstant(ZoneOffset offset)` 返回一份本 `OffsetTime`与指定的偏移量确保结果是在一个隐含的同一瞬间。
`OffsetTime`	`withOffsetSameLocal(ZoneOffset offset)` 返回一份本 `OffsetTime`与指定的偏移量确保结果具有相同的本地时间。
`OffsetTime`	`withSecond(int second)` 返回一份本 `OffsetTime`第二分钟值改变。

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

- Field Detail
  - MIN
```
public static final OffsetTime MIN
```
    最小支持 OffsetTime，' 00:00:00 + 18:00”。这是午夜的时候在开始的一天的最大偏移量（较大的偏移量是早期的时间线）。这将 LocalTime.MIN和 ZoneOffset.MAX。这可以被一个应用程序作为一个“遥远的”日期。
  - MAX
```
public static final OffsetTime MAX
```
    所支持的最大 OffsetTime，“23:59:59. 999999999 -18:00”。这是午夜前的时间在一天结束时的最小偏移量（较大的负偏移量是后来的时间线）。这将 LocalTime.MAX和 ZoneOffset.MIN。这可以被一个应用程序作为一个“遥远的未来”日期。
- 方法详细信息
  - now
```
public static OffsetTime now()
```
    在默认时区中从系统时钟获取当前时间。
    这将查询system clock在默认时区获取当前时间。偏移量将从时钟的时区计算。
    
    使用这种方法将防止使用另一个时钟进行测试的能力，因为时钟是硬编码的。
    
    结果
    
    当前使用的系统时钟，不为空
  - now
```
public static OffsetTime now(ZoneId zone)
```
    从指定时区中的系统时钟中获得当前时间。
    这将查询system clock获取当前时间。指定时区避免依赖于默认时区。偏移量将从指定的时区计算出来。
    
    使用这种方法将防止使用另一个时钟进行测试的能力，因为时钟是硬编码的。
    
    参数
    
    zone -区ID使用，不为空
    
    结果
    
    当前使用的系统时钟，不为空
  - now
```
public static OffsetTime now(Clock clock)
```
    从指定的时钟获取当前时间。
    这将查询指定的时钟，以获得当前时间。偏移量将从时钟的时区计算。
    
    使用这种方法允许使用一个备用时钟进行测试。备用时钟可采用dependency injection。
    
    参数
    
    clock -时钟使用，不为空
    
    结果
    
    当前时间，而不是空
  - of
```
public static OffsetTime of(LocalTime time,
                            ZoneOffset offset)
```
    获得 OffsetTime实例从本地时间偏移。
    
    参数
    
    time -当地时间，不空
    
    offset -区偏移，不空
    
    结果
    
    偏移时间，不为空
  - of
```
public static OffsetTime of(int hour,
                            int minute,
                            int second,
                            int nanoOfSecond,
                            ZoneOffset offset)
```
    获得 OffsetTime实例每小时，，二和纳秒。
    这将创建一个偏移时间与四个指定的字段。
    
    这种方法主要存在于编写测试用例的情况下。非测试代码通常会使用其他方法来创建一个偏移时间。LocalTime具有以减少参数等效工厂方法两个额外的方便的变种。他们没有在这里提供减少的足迹的原料药。
    
    参数
    
    hour -天代表小时，从0到23
    
    minute -小时代表分钟，从0到59
    
    second -二分为代表，从0到59
    
    nanoOfSecond -二代表纳米，从0到999999999
    
    offset -区偏移，不空
    
    结果
    
    偏移时间，不为空
    
    异常
    
    DateTimeException -如果任何字段的值超出范围
  - ofInstant
```
public static OffsetTime ofInstant(Instant instant,
                                   ZoneId zone)
```
    获得 OffsetTime实例从一个 Instant区
    这将创建一个与指定的相同时刻的偏移时间。发现从UTC /格林尼治偏简单有每个时刻只有一个有效的抵消。
    
    在转换过程中，即时的日期组件被删除。这意味着转换永远不会失败，因为即时被淘汰的有效范围内的日期。
    ID。
    
    参数
    
    instant -创造时间的瞬间，不为空
    
    zone的时区，这可能是一个偏移量，不为空
    
    结果
    
    偏移时间，不为空
  - from
```
public static OffsetTime from(TemporalAccessor temporal)
```
    获得 OffsetTime实例从一个时空对象。
    这将获得一个基于指定时间的偏移时间。一个TemporalAccessor表示日期和时间信息，任意设置，本厂将以OffsetTime实例。
    
    转换提取物结合ZoneOffset从时空对象的LocalTime。实现允许执行优化，如访问这些字段，这些字段相当于相关对象。
    
    这种方法相匹配的功能接口TemporalQuery可以通过方法引用查询中的签名，OffsetTime::from。
    
    参数
    
    temporal -转换时间的对象，不为空
    
    结果
    
    偏移时间，不为空
    
    异常
    
    DateTimeException如果无法转换到一个 OffsetTime
  - parse
```
public static OffsetTime parse(CharSequence text)
```
    获得 OffsetTime实例从一个文本字符串，如 10:15:30+01:00。
    该字符串必须是一个有效的时间和使用DateTimeFormatter.ISO_OFFSET_TIME解析。
    
    参数
    
    text -解析如“10:15:30 + 01:00”文本，不空
    
    结果
    
    解析的本地时间，而不是空
    
    异常
    
    DateTimeParseException如果文本不能解析
  - parse
```
public static OffsetTime parse(CharSequence text,
                               DateTimeFormatter formatter)
```
    获得 OffsetTime实例从使用特定格式的文本字符串。
    文字使用格式化程序解析，返回时间。
    
    参数
    
    text -解析文本，不空
    
    formatter -格式化程序使用，不为空
    
    结果
    
    解析的偏移时间，而不是空
    
    异常
    
    DateTimeParseException如果文本不能解析
  - isSupported
```
public boolean isSupported(TemporalField field)
```
    检查指定字段是否被支持。
    此检查，如果这个时间可以查询指定的字段。如果为false，则调用range，get和with(TemporalField, long)方法将抛出一个异常。
    
    如果该字段是ChronoField然后查询执行。支持的字段是：
    - NANO_OF_SECOND
    - NANO_OF_DAY
    - MICRO_OF_SECOND
    - MICRO_OF_DAY
    - MILLI_OF_SECOND
    - MILLI_OF_DAY
    - SECOND_OF_MINUTE
    - SECOND_OF_DAY
    - MINUTE_OF_HOUR
    - MINUTE_OF_DAY
    - HOUR_OF_AMPM
    - CLOCK_HOUR_OF_AMPM
    - HOUR_OF_DAY
    - CLOCK_HOUR_OF_DAY
    - AMPM_OF_DAY
    - OFFSET_SECONDS
    所有其他 ChronoField实例将返回false。
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.isSupportedBy(TemporalAccessor)得到此方法的结果。是否支持字段由字段确定。
    Specified by:
    
    isSupported 接口 TemporalAccessor
    
    参数
    
    field -现场检查null返回false
    
    结果
    
    如果在这个时间域上支持，如果不支持的话
  - isSupported
```
public boolean isSupported(TemporalUnit unit)
```
    检查指定的单位是否被支持。
    此检查如果指定的单位可以添加到或减去，这个日期时间。如果为false，则调用plus(long, TemporalUnit)和minus方法将抛出一个异常。
    
    如果单位是一个ChronoUnit然后查询执行。所支持的单位是：
    - NANOS
    - MICROS
    - MILLIS
    - SECONDS
    - MINUTES
    - HOURS
    - HALF_DAYS
    所有其他 ChronoUnit实例将返回false。
    如果单位不ChronoUnit，然后通过调用作为参数传递this TemporalUnit.isSupportedBy(Temporal)得到此方法的结果。是否支持单位是由单位确定的。
    Specified by:
    
    isSupported 接口 Temporal
    
    参数
    
    unit -检查单元，空返回false
    
    结果
    
    如果单位可以增加/减去，如果没有的话
  - range
```
public ValueRange range(TemporalField field)
```
    获取指定字段的有效值的范围。
    该范围对象表示字段的最小值和最大有效值。这个时间是用来提高返回范围的准确性。如果它是不可能返回的范围，因为字段不支持或其他一些原因，抛出一个异常。
    
    如果该字段是ChronoField然后查询执行。的supported fields将返回适当的范围的情况下。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.rangeRefinedBy(TemporalAccessor)得到此方法的结果。是否可以得到范围是由字段确定的。
    
    Specified by:
    
    range 接口 TemporalAccessor
    
    参数
    
    field -现场查询范围，不为空
    
    结果
    
    字段的有效值的范围，而不是空值
    
    异常
    
    DateTimeException如果不能得到的领域范围
    
    UnsupportedTemporalTypeException如果字段不支持
  - get
```
public int get(TemporalField field)
```
    获取指定字段的值，从这个时间作为一个 int。
    此查询此时间为指定字段的值。返回的值将始终在字段的有效值范围内。如果不可能返回值，因为字段不支持或其他原因，则抛出异常。
    
    如果该字段是ChronoField然后查询执行。的supported fields将基于时间的有效值，除了NANO_OF_DAY和MICRO_OF_DAY太大，安装在一个int、扔DateTimeException。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.getFrom(TemporalAccessor)得到此方法的结果。是否可以得到值，以及值表示的值，由字段确定。
    
    Specified by:
    
    get 接口 TemporalAccessor
    
    参数
    
    field -领域有，不空
    
    结果
    
    字段的值
    
    异常
    
    DateTimeException如果字段的值是不能获得或值不在字段的有效值范围内
    
    UnsupportedTemporalTypeException -如果字段不支持或值的范围超过一个 int
    
    ArithmeticException如果数值溢出时
  - getLong
```
public long getLong(TemporalField field)
```
    获取指定字段的值，从这个时间作为一个 long。
    此查询此时间为指定字段的值。如果不可能返回值，因为字段不支持或其他原因，则抛出异常。
    
    如果该字段是ChronoField然后查询执行。的supported fields将基于时间的有效值。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.getFrom(TemporalAccessor)得到此方法的结果。是否可以得到值，以及值表示的值，由字段确定。
    
    Specified by:
    
    getLong 接口 TemporalAccessor
    
    参数
    
    field -领域有，不空
    
    结果
    
    字段的值
    
    异常
    
    DateTimeException如果不能得到一个价值领域
    
    UnsupportedTemporalTypeException如果字段不支持
    
    ArithmeticException如果数值溢出时
  - getOffset
```
public ZoneOffset getOffset()
```
    能带偏移，如“+”01:00。
    这是从UTC /格林尼治本地时间偏移。
    
    结果
    
    区域偏移，不为空
  - withOffsetSameLocal
```
public OffsetTime withOffsetSameLocal(ZoneOffset offset)
```
    返回一份本 OffsetTime与指定的偏移量确保结果具有相同的本地时间。
    此方法返回具有相同的LocalTime和指定的ZoneOffset对象。没有计算是必要的或执行。例如，如果这个时候代表10:30+02:00和偏移指定+03:00，此方法将返回10:30+03:00。
    
    考虑到之间的偏移量的差异，以及时间方面的调整，使用withOffsetSameInstant(java.time.ZoneOffset)。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    offset -带偏移改变，不为空
    
    结果
    
    基于这一次请求的抵消 OffsetTime，不空
  - withOffsetSameInstant
```
public OffsetTime withOffsetSameInstant(ZoneOffset offset)
```
    返回一份本 OffsetTime与指定的偏移量确保结果是在一个隐含的同一瞬间。
    此方法返回与指定的ZoneOffset和LocalTime由两个偏移量之间的差异调整对象。这将导致在旧的和新的对象，代表相同的即时一个隐含的一天。这是有用的，寻找当地时间在一个不同的偏移。例如，如果这个时候代表10:30+02:00和偏移指定+03:00，此方法将返回11:30+03:00。
    
    改变偏移没有调整本地时间使用withOffsetSameLocal(java.time.ZoneOffset)。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    offset -带偏移改变，不为空
    
    结果
    
    基于这一次请求的抵消 OffsetTime，不空
  - toLocalTime
```
public LocalTime toLocalTime()
```
    获取此日期时间的 LocalTime部分。
    这将返回一个具有相同的小时，分钟LocalTime，二和纳秒这个日期时间。
    
    结果
    
    这个日期时间的时间部分，不是空的
  - getHour
```
public int getHour()
```
    获取天字段的时间。
    
    结果
    
    一天一小时，从0天到23天
  - getMinute
```
public int getMinute()
```
    获取小时字段的分钟。
    
    结果
    
    每小时，从0到59
  - getSecond
```
public int getSecond()
```
    获取第二个分钟字段。
    
    结果
    
    第二分钟，从0分到59分
  - getNano
```
public int getNano()
```
    获取第二场的纳米。
    
    结果
    
    纳米第二，从0到999999999
  - with
```
public OffsetTime with(TemporalAdjuster adjuster)
```
    返回此时间的调整副本。
    这将返回一个OffsetTime，基于此，随着时间的调整。调整使用指定的调整器策略对象。阅读调整器的文档，了解将要做什么调整。
    
    一个简单的调节器可以简单地设置一个字段，例如小时字段。一个更复杂的调节器可能会把时间定在一天的最后一个小时。
    
    这类LocalTime和ZoneOffset实施TemporalAdjuster，因此该方法可用于更改时间或偏移：
```
结果：offsettime与（时间）；结果：offsettime。与（偏移）；
```
    这种方法的结果是通过调用指定的调节器，通过this作为论据的TemporalAdjuster.adjustInto(Temporal)方法得到的。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    with 接口 Temporal
    
    参数
    
    adjuster -调节器使用，不为空
    
    结果
    
    基于调整 this一 OffsetTime，不空
    
    异常
    
    DateTimeException -如果调整不能
    
    ArithmeticException如果数值溢出时
  - with
```
public OffsetTime with(TemporalField field,
                       long newValue)
```
    将此时间的副本与指定的字段设置为一个新值。
    这将返回一个OffsetTime，在此基础上，对指定字段的值的变化。这可以用来改变任何支持的领域，如小时，分钟或秒。如果不可能设置值，因为字段不支持或其他原因，则抛出异常。
    
    如果该字段是ChronoField然后调整在这里实现。
    
    的OFFSET_SECONDS场将返回与指定的时间偏移。本地时间是不变的。如果新的偏移值超出有效范围，则会抛出DateTimeException。
    
    另supported fields将表现为每个匹配的方法LocalTime.with(TemporalField, long) localtime }。在这种情况下，偏移量不是计算的一部分，并且将保持不变。
    
    所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.adjustInto(Temporal, long)得到此方法的结果。在这种情况下，字段决定是否以及如何调整即时。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    with 接口 Temporal
    
    参数
    
    field -现场设置的结果，不为空
    
    newValue -场的结果中的新价值
    
    结果
    
    基于指定的字段设置一个 OffsetTime this，不空
    
    异常
    
    DateTimeException -如果该字段不能设置
    
    UnsupportedTemporalTypeException如果字段不支持
    
    ArithmeticException如果数值溢出时
  - withHour
```
public OffsetTime withHour(int hour)
```
    返回一份本 OffsetTime与一个值改变。
    偏移量不影响计算，结果在结果中是相同的。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hour -天时设置的结果，从0到23
    
    结果
    
    基于这一 OffsetTime时间与请求时，不为空
    
    异常
    
    DateTimeException -如果时间值无效
  - withMinute
```
public OffsetTime withMinute(int minute)
```
    返回一份本 OffsetTime与分钟小时值改变。
    偏移量不影响计算，结果在结果中是相同的。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minute -小时设置在结果的那一刻，从0到59
    
    结果
    
    基于这一次请求一个 OffsetTime分钟，不空
    
    异常
    
    DateTimeException如果分钟值无效
  - withSecond
```
public OffsetTime withSecond(int second)
```
    返回一份本 OffsetTime第二分钟值改变。
    偏移量不影响计算，结果在结果中是相同的。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    second -二分钟设置的结果，从0到59
    
    结果
    
    基于这一次请求的第二 OffsetTime，不空
    
    异常
    
    DateTimeException如果二值无效
  - withNano
```
public OffsetTime withNano(int nanoOfSecond)
```
    返回一份本 OffsetTime与纳米二值改变。
    偏移量不影响计算，结果在结果中是相同的。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanoOfSecond -二设置结果纳米，从0到999999999
    
    结果
    
    基于这一次请求一个 OffsetTime纳秒，不空
    
    异常
    
    DateTimeException如果Nano值无效
  - truncatedTo
```
public OffsetTime truncatedTo(TemporalUnit unit)
```
    返回一份本 OffsetTime与定时。
    截断返回一个原始时间的副本，该字段小于指定的单位设置为零的字段。例如，截断与minutes单元组分，第二场零纳米二。
    
    单位必须有一个duration分成标准节长度无余。这包括所有提供的时间单位ChronoUnit和DAYS。其他单位抛出一个异常。
    
    偏移量不影响计算，结果在结果中是相同的。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    unit -单位截形，不为空
    
    结果
    
    在此基础上加上时间的 OffsetTime截断，不空
    
    异常
    
    DateTimeException如果无法截断
    
    UnsupportedTemporalTypeException如果单位不支持
  - plus
```
public OffsetTime plus(TemporalAmount amountToAdd)
```
    返回此时间的副本，添加指定的金额。
    这将返回一个OffsetTime，在此基础上，用指定的添加量。量通常是Duration但可能是任何其他类型的TemporalAmount接口实现。
    
    计算委托量对象通过调用TemporalAmount.addTo(Temporal)。执行金额是免费在任何情况下它的愿望实现，但是它通常称为回plus(long, TemporalUnit)。咨询量的执行文件以确定它是否可以成功添加。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    plus 接口 Temporal
    
    参数
    
    amountToAdd -添加量，不为空
    
    结果
    
    在此基础上加入了 OffsetTime，不空
    
    异常
    
    DateTimeException如果还不能
    
    ArithmeticException如果数值溢出时
  - plus
```
public OffsetTime plus(long amountToAdd,
                       TemporalUnit unit)
```
    返回此时间的副本，添加指定的金额。
    这将返回一个OffsetTime，基于此，在单元的添加量。如果它是不可能添加的量，因为该单元不支持或其他原因，则抛出异常。
    
    如果该字段是ChronoUnit然后通过LocalTime.plus(long, TemporalUnit)之外。偏移量不是计算的一部分，在结果中会保持不变。
    
    如果该字段是不是ChronoUnit，然后通过调用作为参数传递this TemporalUnit.addTo(Temporal, long)得到此方法的结果。在这种情况下，该单元确定是否和如何执行加法。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    plus 接口 Temporal
    
    参数
    
    amountToAdd -单位的数量增加的结果，可能是负面的
    
    unit -量的单位添加，不为空
    
    结果
    
    基于此时间与额度增加了 OffsetTime，不空
    
    异常
    
    DateTimeException如果还不能
    
    UnsupportedTemporalTypeException如果单位不支持
    
    ArithmeticException如果数值溢出时
  - plusHours
```
public OffsetTime plusHours(long hours)
```
    返回一份本 OffsetTime在指定时间内添加时间。
    这增加了指定的时间数，以这个时间，返回一个新的时间。计算环绕午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hours -添加时间，可能是负面的
    
    结果
    
    基于这一次的时间增加了一个 OffsetTime，不空
  - plusMinutes
```
public OffsetTime plusMinutes(long minutes)
```
    返回一份本 OffsetTime在几分钟之内指定期间补充。
    这增加了指定的数分钟到这个时间，返回一个新的时间。计算环绕午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minutes -添加记录，可能是负面的
    
    结果
    
    基于这一时间的分钟 OffsetTime补充道，不空
  - plusSeconds
```
public OffsetTime plusSeconds(long seconds)
```
    返回一份本 OffsetTime在指定时间内增加秒。
    这增加了指定的秒数，返回一个新的时间。计算环绕午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    seconds -加秒，可能是负面的
    
    结果
    
    基于此时间与秒 OffsetTime补充道，不空
  - plusNanos
```
public OffsetTime plusNanos(long nanos)
```
    返回一份本 OffsetTime在纳秒指定期间补充。
    这增加了指定数纳秒到这个时候，返回一个新的时间。计算环绕午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanos -添加纳米，可能是负面的
    
    结果
    
    基于这一时间在纳秒 OffsetTime补充道，不空
  - minus
```
public OffsetTime minus(TemporalAmount amountToSubtract)
```
    返回此时间的副本与指定的金额减去。
    这将返回一个OffsetTime，在此基础上，用指定的金额减去。量通常是Duration但可能是任何其他类型的TemporalAmount接口实现。
    
    计算委托量对象通过调用TemporalAmount.subtractFrom(Temporal)。量实现自由以任何方式希望实现减法，但它通常需要回minus(long, TemporalUnit)。咨询量的执行文件以确定它是否可以成功地减去。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus 接口 Temporal
    
    参数
    
    amountToSubtract -减去的量，不为空
    
    结果
    
    基于此时间与减了 OffsetTime，不空
    
    异常
    
    DateTimeException如果减法不能做
    
    ArithmeticException如果数值溢出时
  - minus
```
public OffsetTime minus(long amountToSubtract,
                        TemporalUnit unit)
```
    返回此时间的副本与指定的金额减去。
    这将返回一个OffsetTime，在此基础上，对单位金额减去。如果它是不可能的减去的量，因为该单位不支持或一些其他原因，一个异常被抛出。
    
    这种方法是相当的金额plus(long, TemporalUnit)否定。见该方法充分说明了如何加法，从而减法，作品。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus 接口 Temporal
    
    参数
    
    amountToSubtract -减去从结果数额的单位，可能是负面的
    
    unit -金额单位减，不为空
    
    结果
    
    基于这一次指定的金额减去一个 OffsetTime，不空
    
    异常
    
    DateTimeException如果减法不能做
    
    UnsupportedTemporalTypeException如果单位不支持
    
    ArithmeticException如果数值溢出时
  - minusHours
```
public OffsetTime minusHours(long hours)
```
    返回一份本 OffsetTime减去指定的时间在小时。
    这中减去指定的小时数从这个时间，返回一个新的时间。计算环绕午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hours -减小时，可能是负面的
    
    结果
    
    基于此时间与时间中减去一个 OffsetTime，不空
  - minusMinutes
```
public OffsetTime minusMinutes(long minutes)
```
    返回一份本 OffsetTime在几分钟之内减去指定的时间。
    这中减去指定的分钟数，从这个时候起，返回一个新的时间。计算环绕午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minutes -减分，可能是负面的
    
    结果
    
    基于这一次记录中减去一个 OffsetTime，不空
  - minusSeconds
```
public OffsetTime minusSeconds(long seconds)
```
    返回一份本 OffsetTime与指定期秒减去。
    这中减去指定的秒数，从这个时候起，返回一个新的时间。计算环绕午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    seconds -减去秒，可能是负面的
    
    结果
    
    基于此时间与秒减去一个 OffsetTime，不空
  - minusNanos
```
public OffsetTime minusNanos(long nanos)
```
    返回一份本 OffsetTime减去指定的时间在纳秒。
    这将指定数纳秒从这个时间，返回一个新的时间。计算环绕午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanos -减去这些可能是负面的
    
    结果
    
    基于此时间与纳秒中减去一个 OffsetTime，不空
  - query
```
public <R> R query(TemporalQuery<R> query)
```
    使用指定的查询查询此时间。
    此查询使用指定的查询策略对象进行此查询。的TemporalQuery对象定义了用来获得结果的逻辑。阅读查询的文档，了解该方法的结果将是什么。
    
    这种方法的结果是通过调用指定的查询通过this作为论据的TemporalQuery.queryFrom(TemporalAccessor)方法得到的。
    
    Specified by:
    
    query 接口 TemporalAccessor
    
    参数类型
    
    R -结果的类型
    
    参数
    
    query -调用查询，不空
    
    结果
    
    查询结果，可以返回（由查询所定义）
    
    异常
    
    DateTimeException如果无法查询（查询所定义）
    
    ArithmeticException如果数值溢出时（由查询定义）
  - adjustInto
```
public Temporal adjustInto(Temporal temporal)
```
    调整指定的时间对象，以具有相同的偏移和时间为这个对象。
    这将返回一个相同的可观察类型的时间对象，作为输入的偏移量和时间改变了，这是相同的。
    
    调整是相当于用Temporal.with(TemporalField, long)两次，通过ChronoField.NANO_OF_DAY和ChronoField.OFFSET_SECONDS的领域。
    
    在大多数情况下，更清晰的用Temporal.with(TemporalAdjuster)反向调用模式：
```
这两条线是等价的，但第二种方法是建议时间= thisoffsettime adjustinto（时间）；时间=（thisoffsettime）与时间；
```
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    adjustInto 接口 TemporalAdjuster
    
    参数
    
    temporal -调整目标对象，不为空
    
    结果
    
    调整后的对象，而不是空
    
    异常
    
    DateTimeException如果无法适应
    
    ArithmeticException如果数值溢出时
  - until
```
public long until(Temporal endExclusive,
                  TemporalUnit unit)
```
    计算时间的量，直到另一个时间在指定的单位。
    这两OffsetTime计算对象之间的时间量在一个TemporalUnit条款。开始和结束点this和指定的时间。结果将是负的，如果结束之前开始。例如，在两次小时的周期可以计算startTime.until(endTime, HOURS)。
    
    的Temporal传递给此方法转换为OffsetTime使用from(TemporalAccessor)。如果偏移量之间的两次不同，那么指定的结束时间被归一化，以具有相同的偏移量，因为这一次。
    
    计算返回一个整数，表示两次之间的完全单位数。例如，在11:30z和13:29z之间时间只有一个小时的时间就短两小时一分钟。
    
    使用这种方法有两个等效的方法。首先是调用这个方法。二是用TemporalUnit.between(Temporal, Temporal)：
```
这两条线是等价的开始，直到（结束，分钟）；金额=分钟。之间（开始，结束）；
```
    的选择应基于使得代码更易读。
    计算中实现该方法ChronoUnit。单位NANOS，MICROS，MILLIS，SECONDS，MINUTES，HOURS和HALF_DAYS支持。其他ChronoUnit值将抛出一个异常。
    
    如果单位不ChronoUnit，然后通过调用TemporalUnit.between(Temporal, Temporal) this作为第一个参数传递和转换的输入时间作为第二个参数给出了这个方法的结果。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    until 接口 Temporal
    
    参数
    
    endExclusive -结束日期，独家的，它被转换为一个 OffsetTime，不空
    
    unit -单位量来衡量，不为空
    
    结果
    
    这个时间和结束时间之间的时间
    
    异常
    
    DateTimeException如果金额无法计算，或结束时间不能转换为 OffsetTime
    
    UnsupportedTemporalTypeException如果单位不支持
    
    ArithmeticException如果数值溢出时
  - format
```
public String format(DateTimeFormatter formatter)
```
    格式时使用指定的格式化程序。
    这一次将通过格式化程序产生一个字符串。
    
    参数
    
    formatter -格式化程序使用，不为空
    
    结果
    
    格式化的时间字符串，而不是空的
    
    异常
    
    DateTimeException如果打印时发生错误
  - atDate
```
public OffsetDateTime atDate(LocalDate date)
```
    结合时间与日期创建一个 OffsetDateTime。
    这将返回一个OffsetDateTime从此形成和指定的日期。日期和时间的所有可能的组合都是有效的。
    
    参数
    
    date -日期的结合，不为空
    
    结果
    
    从这个时间和指定日期形成的偏移日期时间，而不是空值
  - compareTo
```
public int compareTo(OffsetTime other)
```
    比较这 OffsetTime到另一个时间。
    比较首先是基于UTC等效的瞬间，然后在当地时间。这是“等于”一致，所定义的Comparable。
    
    例如，下面是比较器的顺序：
    1. 10:30+01:00
    2. 11:00+01:00
    3. 12:00+02:00
    4. 11:30+01:00
    5. 12:00+01:00
    6. 12:30+01:00
    值2和3 # #代表时间线的一瞬间。当两个值代表相同的瞬间，当地的时间进行比较，以区分它们。这一步是需要进行排序的一致 equals()。
    比较两TemporalAccessor实例的本地时间，使用ChronoField.NANO_OF_DAY作为比较器。
    Specified by:
    
    compareTo 接口 Comparable<OffsetTime>
    
    参数
    
    other -相比其他时间，不空
    
    结果
    
    比较器的值，负的，如果少，积极的，如果更大
    
    异常
    
    NullPointerException -如果 other是空的
  - isAfter
```
public boolean isAfter(OffsetTime other)
```
    检查，如果这 OffsetTime瞬间之后的指定时间应用时代一个普通的日子。
    这种方法不同于在compareTo(java.time.OffsetTime)在比较，只是比较的时间瞬间。这相当于将两次即时使用相同的日期与时刻。
    
    参数
    
    other -相比其他时间，不空
    
    结果
    
    这是真的，如果这是在指定的时间后
  - isBefore
```
public boolean isBefore(OffsetTime other)
```
    检查，如果这 OffsetTime瞬间之前指定的时间运用时间一个普通的日子。
    这种方法不同于在compareTo(java.time.OffsetTime)在比较，只是比较的时间瞬间。这相当于将两次即时使用相同的日期与时刻。
    
    参数
    
    other -相比其他时间，不空
    
    结果
    
    这是真的，如果这是在指定时间的瞬间
  - isEqual
```
public boolean isEqual(OffsetTime other)
```
    检查，如果这 OffsetTime即时等于指定的时间运用时间一个普通的日子。
    这种方法不同于compareTo(java.time.OffsetTime)和equals(java.lang.Object)比较，只是比较的时间瞬间。这相当于将两次即时使用相同的日期与时刻。
    
    参数
    
    other -相比其他时间，不空
    
    结果
    
    如果这是等于指定时间的瞬间
  - equals
```
public boolean equals(Object obj)
```
    检查这个时间是否等于另一个时间。
    比较是基于本地时间和偏移量。在时间线的一瞬间相比，使用isEqual(OffsetTime)。
    
    OffsetTime型只有对象相比，其他类型返回false。比较两TemporalAccessor实例的本地时间，使用ChronoField.NANO_OF_DAY作为比较器。
    
    重写：
    
    equals 方法重写，继承类 Object
    
    参数
    
    obj -检查对象，空返回false
    
    结果
    
    如果这是等于另一时间
    
    另请参见：
    
    Object.hashCode()， HashMap
  - hashCode
```
public int hashCode()
```
    这个时候的一个哈希代码。
    
    重写：
    
    hashCode 方法重写，继承类 Object
    
    结果
    
    一个合适的哈希代码
    
    另请参见：
    
    Object.equals(java.lang.Object)， System.identityHashCode(java.lang.Object)
  - toString
```
public String toString()
```
    输出这个时间作为一个 String，如 10:15:30+01:00。
    输出将下列ISO-8601格式：
    - HH:mmXXXXX
    - HH:mm:ssXXXXX
    - HH:mm:ss.SSSXXXXX
    - HH:mm:ss.SSSSSSXXXXX
    - HH:mm:ss.SSSSSSSSSXXXXX
    所用的格式将最短，输出的全部价值的时候，省略部分是暗示为零。
    重写：
    
    toString 方法重写，继承类 Object
    
    结果
    
    这个时间的字符串表示，不是空的

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class OffsetTime

Field Summary

方法摘要

Methods inherited from class java.lang.Object

Field Detail

MIN

MAX

方法详细信息

now

now

now

of

of

ofInstant

from

parse

parse

isSupported

isSupported

range

get

getLong

getOffset

withOffsetSameLocal

withOffsetSameInstant

toLocalTime

getHour

getMinute

getSecond

getNano

with

with

withHour

withMinute

withSecond

withNano

truncatedTo

plus

plus

plusHours

plusMinutes

plusSeconds

plusNanos

minus

minus

minusHours

minusMinutes

minusSeconds

minusNanos

query

adjustInto

until

format

atDate

compareTo

isAfter

isBefore

isEqual

equals

hashCode

toString