LocalTime (Java Platform SE 8 )

java.lang.Object
- java.time.LocalTime

All Implemented Interfaces:

Serializable， Comparable < LocalTime >， Temporal， TemporalAccessor， TemporalAdjuster
```
public final class LocalTime
extends Object
implements Temporal, TemporalAdjuster, Comparable<LocalTime>, Serializable
```
一时间没有时间带在ISO-8601日历系统，如 10:15:30。
LocalTime是不变的日期时间对象代表一个时间，往往被视为小时分钟秒。时间为代表的纳秒级精度。例如，值“13:45.30.123456789”可以存储在一个LocalTime。

它不存储或表示一个日期或时区。相反，它是一个本地时间的描述，如在墙上的时钟。它不能代表时间线上的即时，而不需要额外的信息，如偏移或时区。

该系统是现代民法ISO-8601日历日历系统中使用的大多数今天的世界。这个应用的假设，所有的日历系统都使用相同的表示形式，这一类，一天的时间。

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

实现要求：

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

从以下版本开始：

一点八

另请参见：

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static LocalTime`	`MAX` 所支持的最大 `LocalTime`，“23:59:59. 999999999。
`static LocalTime`	`MIDNIGHT` 在一天的开始，午夜时分，“00:00”。
`static LocalTime`	`MIN` 最小支持 `LocalTime` 00:00，' '。
`static LocalTime`	`NOON` 在一天的中间时间中午12:00，' '。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	Method and Description
`Temporal`	`adjustInto(Temporal temporal)` 调整指定的时间对象，以具有相同的时间为这个对象。
`LocalDateTime`	`atDate(LocalDate date)` 结合时间与日期创建一个 `LocalDateTime`。
`OffsetTime`	`atOffset(ZoneOffset offset)` 结合这一次的偏移来创建一个 `OffsetTime`。
`int`	`compareTo(LocalTime other)` 比较这 `LocalTime`到另一个时间。
`boolean`	`equals(Object obj)` 检查这个时间是否等于另一个时间。
`String`	`format(DateTimeFormatter formatter)` 格式时使用指定的格式化程序。
`static LocalTime`	`from(TemporalAccessor temporal)` 获得 `LocalTime`实例从一个时空对象。
`int`	`get(TemporalField field)` 获取指定字段的值，从这个时间作为一个 `int`。
`int`	`getHour()` 获取天字段的时间。
`long`	`getLong(TemporalField field)` 获取指定字段的值，从这个时间作为一个 `long`。
`int`	`getMinute()` 获取小时字段的分钟。
`int`	`getNano()` 获取第二场的纳米。
`int`	`getSecond()` 获取第二个分钟字段。
`int`	`hashCode()` 这个时候的一个哈希代码。
`boolean`	`isAfter(LocalTime other)` 如果这个检查 `LocalTime`是指定的时间后。
`boolean`	`isBefore(LocalTime other)` 如果这个检查是在规定的时间 `LocalTime`。
`boolean`	`isSupported(TemporalField field)` 检查指定字段是否被支持。
`boolean`	`isSupported(TemporalUnit unit)` 检查指定的单位是否被支持。
`LocalTime`	`minus(long amountToSubtract, TemporalUnit unit)` 返回此时间的副本与指定的金额减去。
`LocalTime`	`minus(TemporalAmount amountToSubtract)` 返回此时间的副本与指定的金额减去。
`LocalTime`	`minusHours(long hoursToSubtract)` 返回一份本 `LocalTime`减去指定的时间在小时。
`LocalTime`	`minusMinutes(long minutesToSubtract)` 返回一份本 `LocalTime`在几分钟之内减去指定的时间。
`LocalTime`	`minusNanos(long nanosToSubtract)` 返回一份本 `LocalTime`减去指定的时间在纳秒。
`LocalTime`	`minusSeconds(long secondsToSubtract)` 返回一份本 `LocalTime`与指定期秒减去。
`static LocalTime`	`now()` 在默认时区中从系统时钟获取当前时间。
`static LocalTime`	`now(Clock clock)` 从指定的时钟获取当前时间。
`static LocalTime`	`now(ZoneId zone)` 从指定时区中的系统时钟中获得当前时间。
`static LocalTime`	`of(int hour, int minute)` 获得 `LocalTime`实例从一个小时和分钟。
`static LocalTime`	`of(int hour, int minute, int second)` 获得 `LocalTime`实例从一个小时、分钟和秒。
`static LocalTime`	`of(int hour, int minute, int second, int nanoOfSecond)` 获得 `LocalTime`实例每小时，，二和纳秒。
`static LocalTime`	`ofNanoOfDay(long nanoOfDay)` 获得 `LocalTime`实例从3日价值。
`static LocalTime`	`ofSecondOfDay(long secondOfDay)` 获得 `LocalTime`实例从一第二天价值。
`static LocalTime`	`parse(CharSequence text)` 获得 `LocalTime`实例从一个文本字符串，如 `10:15`。
`static LocalTime`	`parse(CharSequence text, DateTimeFormatter formatter)` 获得 `LocalTime`实例从使用特定格式的文本字符串。
`LocalTime`	`plus(long amountToAdd, TemporalUnit unit)` 返回此时间的副本，添加指定的金额。
`LocalTime`	`plus(TemporalAmount amountToAdd)` 返回此时间的副本，添加指定的金额。
`LocalTime`	`plusHours(long hoursToAdd)` 返回一份本 `LocalTime`在指定时间内添加时间。
`LocalTime`	`plusMinutes(long minutesToAdd)` 返回一份本 `LocalTime`在几分钟之内指定期间补充。
`LocalTime`	`plusNanos(long nanosToAdd)` 返回一份本 `LocalTime`在纳秒指定期间补充。
`LocalTime`	`plusSeconds(long secondstoAdd)` 返回一份本 `LocalTime`在指定时间内增加秒。
`<R> R`	`query(TemporalQuery<R> query)` 使用指定的查询查询此时间。
`ValueRange`	`range(TemporalField field)` 获取指定字段的有效值的范围。
`long`	`toNanoOfDay()` 提取时间为3天，从 `0`到 `24 * 60 * 60 * 1,000,000,000 - 1`。
`int`	`toSecondOfDay()` 提取时间为秒的日子，从 `0`到 `24 * 60 * 60 - 1`。
`String`	`toString()` 输出这个时间作为一个 `String`，如 `10:15`。
`LocalTime`	`truncatedTo(TemporalUnit unit)` 返回一份本 `LocalTime`与定时。
`long`	`until(Temporal endExclusive, TemporalUnit unit)` 计算时间的量，直到另一个时间在指定的单位。
`LocalTime`	`with(TemporalAdjuster adjuster)` 返回此时间的调整副本。
`LocalTime`	`with(TemporalField field, long newValue)` 将此时间的副本与指定的字段设置为一个新值。
`LocalTime`	`withHour(int hour)` 返回一份本 `LocalTime`与一个值改变。
`LocalTime`	`withMinute(int minute)` 返回一份本 `LocalTime`与分钟小时值改变。
`LocalTime`	`withNano(int nanoOfSecond)` 返回一份本 `LocalTime`与纳米二值改变。
`LocalTime`	`withSecond(int second)` 返回一份本 `LocalTime`第二分钟值改变。

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

- Field Detail
  - MIN
```
public static final LocalTime MIN
```
    最小支持 LocalTime 00:00，' '。这是午夜的时候在一天的开始。
  - MAX
```
public static final LocalTime MAX
```
    所支持的最大 LocalTime，“23:59:59. 999999999。这是在一天结束前午夜的时候。
  - MIDNIGHT
```
public static final LocalTime MIDNIGHT
```
    在一天的开始，午夜时分，“00:00”。
  - NOON
```
public static final LocalTime NOON
```
    在一天的中间时间中午12:00，' '。
- 方法详细信息
  - now
```
public static LocalTime now()
```
    在默认时区中从系统时钟获取当前时间。
    这将查询system clock在默认时区获取当前时间。
    
    使用这种方法将防止使用另一个时钟进行测试的能力，因为时钟是硬编码的。
    
    结果
    
    当前使用的系统时钟和默认时区，而不是空
  - now
```
public static LocalTime now(ZoneId zone)
```
    从指定时区中的系统时钟中获得当前时间。
    这将查询system clock获取当前时间。指定时区避免依赖于默认时区。
    
    使用这种方法将防止使用另一个时钟进行测试的能力，因为时钟是硬编码的。
    
    参数
    
    zone -区ID使用，不为空
    
    结果
    
    当前使用的系统时钟，不为空
  - now
```
public static LocalTime now(Clock clock)
```
    从指定的时钟获取当前时间。
    这将查询指定的时钟，以获得当前时间。使用这种方法允许使用一个备用时钟进行测试。备用时钟可采用dependency injection。
    
    参数
    
    clock -时钟使用，不为空
    
    结果
    
    当前时间，而不是空
  - of
```
public static LocalTime of(int hour,
                           int minute)
```
    获得 LocalTime实例从一个小时和分钟。
    返回具有指定的小时和分钟LocalTime。第二个和纳秒级的字段将被设置为零。
    
    参数
    
    hour -天代表小时，从0到23
    
    minute -小时代表分钟，从0到59
    
    结果
    
    本地时间，而不是空
    
    异常
    
    DateTimeException -如果任何字段的值超出范围
  - of
```
public static LocalTime of(int hour,
                           int minute,
                           int second)
```
    获得 LocalTime实例从一个小时、分钟和秒。
    这将返回一个与指定LocalTime小时、分钟和第二。纳秒级场将被设置为零。
    
    参数
    
    hour -天代表小时，从0到23
    
    minute -小时代表分钟，从0到59
    
    second -二分为代表，从0到59
    
    结果
    
    本地时间，而不是空
    
    异常
    
    DateTimeException -如果任何字段的值超出范围
  - of
```
public static LocalTime of(int hour,
                           int minute,
                           int second,
                           int nanoOfSecond)
```
    获得 LocalTime实例每小时，，二和纳秒。
    这将返回一个与指定的小时，分钟LocalTime，二和纳秒。
    
    参数
    
    hour -天代表小时，从0到23
    
    minute -小时代表分钟，从0到59
    
    second -二分为代表，从0到59
    
    nanoOfSecond -二代表纳米，从0到999999999
    
    结果
    
    本地时间，而不是空
    
    异常
    
    DateTimeException -如果任何字段的值超出范围
  - ofSecondOfDay
```
public static LocalTime ofSecondOfDay(long secondOfDay)
```
    获得 LocalTime实例从一第二天价值。
    这将返回一个与指定的第二天LocalTime。纳秒级场将被设置为零。
    
    参数
    
    secondOfDay -天第二，从 0到 24 * 60 * 60 - 1
    
    结果
    
    本地时间，而不是空
    
    异常
    
    DateTimeException -如果一天价值二是无效的
  - ofNanoOfDay
```
public static LocalTime ofNanoOfDay(long nanoOfDay)
```
    获得 LocalTime实例从3日价值。
    这将返回一个与指定日LocalTime纳秒。
    
    参数
    
    nanoOfDay -天纳米，从 0到 24 * 60 * 60 * 1,000,000,000 - 1
    
    结果
    
    本地时间，而不是空
    
    异常
    
    如果一天的价值 DateTimeException Nano是无效的
  - from
```
public static LocalTime from(TemporalAccessor temporal)
```
    获得 LocalTime实例从一个时空对象。
    这获得一个本地时间的基础上指定的时间。一个TemporalAccessor表示日期和时间信息，任意设置，本厂将以LocalTime实例。
    
    转换使用TemporalQueries.localTime()查询，这依赖于提取NANO_OF_DAY场。
    
    这种方法相匹配的功能接口TemporalQuery可以通过方法引用查询中的签名，LocalTime::from。
    
    参数
    
    temporal -转换时间的对象，不为空
    
    结果
    
    本地时间，而不是空
    
    异常
    
    DateTimeException如果无法转换为 LocalTime
  - parse
```
public static LocalTime parse(CharSequence text)
```
    获得 LocalTime实例从一个文本字符串，如 10:15。
    该字符串必须是一个有效的时间和使用DateTimeFormatter.ISO_LOCAL_TIME解析。
    
    参数
    
    text -解析如“10:15:30”文本，不空
    
    结果
    
    解析的本地时间，而不是空
    
    异常
    
    DateTimeParseException如果文本不能解析
  - parse
```
public static LocalTime parse(CharSequence text,
                              DateTimeFormatter formatter)
```
    获得 LocalTime实例从使用特定格式的文本字符串。
    文字使用格式化程序解析，返回时间。
    
    参数
    
    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
    所有其他 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如果数值溢出时
  - 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 LocalTime with(TemporalAdjuster adjuster)
```
    返回此时间的调整副本。
    这将返回一个LocalTime，基于此，随着时间的调整。调整使用指定的调整器策略对象。阅读调整器的文档，了解将要做什么调整。
    
    一个简单的调节器可以简单地设置一个字段，例如小时字段。一个更复杂的调节器可能会把时间定在一天的最后一个小时。
    
    这种方法的结果是通过调用指定的调节器，通过this作为论据的TemporalAdjuster.adjustInto(Temporal)方法得到的。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    with 接口 Temporal
    
    参数
    
    adjuster -调节器使用，不为空
    
    结果
    
    一个 LocalTime基于调整 this，不空
    
    异常
    
    DateTimeException -如果调整不能
    
    ArithmeticException如果数值溢出时
  - with
```
public LocalTime with(TemporalField field,
                      long newValue)
```
    将此时间的副本与指定的字段设置为一个新值。
    这将返回一个LocalTime，在此基础上，对指定字段的值的变化。这可以用来改变任何支持的领域，如小时，分钟或秒。如果不可能设置值，因为字段不支持或其他原因，则抛出异常。
    
    如果该字段是ChronoField然后调整在这里实现。所支持的字段如下：
    - NANO_OF_SECOND -返回与指定的纳米二LocalTime。小时，分钟和第二次将保持不变。
    - NANO_OF_DAY -返回与指定日LocalTime纳米。这完全代替时间和相当于ofNanoOfDay(long)。
    - MICRO_OF_SECOND -返回一个与二由指定的微二乘以1000取代纳米LocalTime。小时，分钟和第二次将保持不变。
    - MICRO_OF_DAY返回具有指定微天LocalTime。这完全取代的时间，相当于使用ofNanoOfDay(long)随着天乘以1000微。
    - MILLI_OF_SECOND -返回一个与二由指定的毫秒二乘以1000000取代纳米LocalTime。小时，分钟和第二次将保持不变。
    - MILLI_OF_DAY -返回与指定日LocalTime毫。这完全取代的时间，相当于使用ofNanoOfDay(long)随着天乘以1000000毫。
    - SECOND_OF_MINUTE -返回与指定的二分LocalTime。第二个小时，分钟和第二秒将保持不变。
    - SECOND_OF_DAY -返回与指定的第二天LocalTime。第二纳米将保持不变。
    - MINUTE_OF_HOUR -返回与指定的分钟小时LocalTime。小时，第二分钟和第二秒将保持不变。
    - MINUTE_OF_DAY -返回与指定的一天LocalTime。第二分钟和第二秒将保持不变。
    - HOUR_OF_AMPM -返回一个指定的时间是下午LocalTime。上午/下午，分钟的小时，第二分钟和第二秒将保持不变。
    - CLOCK_HOUR_OF_AMPM返回与指定的时钟小时LocalTime上午下午。上午/下午，分钟的小时，第二分钟和第二秒将保持不变。
    - HOUR_OF_DAY -返回与指定的时候LocalTime。小时，第二分钟和第二秒将保持不变。
    - CLOCK_HOUR_OF_DAY -返回与指定的时钟小时LocalTime日。小时，第二分钟和第二秒将保持不变。
    - AMPM_OF_DAY返回具有指定AM / PM LocalTime。上午时，分钟的小时，第二分钟和第二秒将保持不变。
    在所有的情况下，如果新的数值超出有效范围的领域，然后DateTimeException将抛出。
    
    所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.adjustInto(Temporal, long)得到此方法的结果。在这种情况下，字段决定是否以及如何调整即时。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    with 接口 Temporal
    
    参数
    
    field -现场设置的结果，不为空
    
    newValue -场的结果中的新价值
    
    结果
    
    一个 LocalTime基于指定的字段集 this，不空
    
    异常
    
    DateTimeException -如果该字段不能设置
    
    UnsupportedTemporalTypeException如果字段不支持
    
    ArithmeticException如果数值溢出时
  - withHour
```
public LocalTime withHour(int hour)
```
    返回一份本 LocalTime与一个值改变。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hour -天在结果集时，从0到23
    
    结果
    
    基于这一 LocalTime时间与请求时，不为空
    
    异常
    
    DateTimeException -如果时间值无效
  - withMinute
```
public LocalTime withMinute(int minute)
```
    返回一份本 LocalTime与分钟小时值改变。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minute -小时设置在结果的那一刻，从0到59
    
    结果
    
    基于这一 LocalTime时间要求的一分钟，不为空
    
    异常
    
    DateTimeException如果分钟值无效
  - withSecond
```
public LocalTime withSecond(int second)
```
    返回一份本 LocalTime第二分钟值改变。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    second -二分钟设置的结果，从0到59
    
    结果
    
    基于这一 LocalTime时间与请求的第二，不空
    
    异常
    
    DateTimeException如果二值无效
  - withNano
```
public LocalTime withNano(int nanoOfSecond)
```
    返回一份本 LocalTime与纳米二值改变。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanoOfSecond -二设置结果纳米，从0到999999999
    
    结果
    
    基于这一 LocalTime时间与请求的纳秒，不空
    
    异常
    
    DateTimeException如果Nano值无效
  - truncatedTo
```
public LocalTime truncatedTo(TemporalUnit unit)
```
    返回一份本 LocalTime与定时。
    截断时间返回一份原始时间字段小于指定的单位设置为零。例如，截断与minutes单元组分，第二场零纳米二。
    
    单位必须有一个duration分成标准节长度无余。这包括所有提供的时间单位和其他单位ChronoUnit DAYS抛出一个异常。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    unit -单位截形，不为空
    
    结果
    
    一个 LocalTime在此基础上加上时间截断，不空
    
    异常
    
    DateTimeException如果无法截断
    
    UnsupportedTemporalTypeException如果单位不支持
  - plus
```
public LocalTime plus(TemporalAmount amountToAdd)
```
    返回此时间的副本，添加指定的金额。
    这将返回一个LocalTime，在此基础上，用指定的添加量。量通常是Duration但可能是任何其他类型的TemporalAmount接口实现。
    
    计算委托量对象通过调用TemporalAmount.addTo(Temporal)。执行金额是免费在任何情况下它的愿望实现，但是它通常称为回plus(long, TemporalUnit)。咨询金额实现的文档，以确定是否可以成功添加。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    plus 接口 Temporal
    
    参数
    
    amountToAdd -添加量，不为空
    
    结果
    
    基于这一 LocalTime时间加，不空
    
    异常
    
    DateTimeException如果还不能
    
    ArithmeticException如果数值溢出时
  - plus
```
public LocalTime plus(long amountToAdd,
                      TemporalUnit unit)
```
    返回此时间的副本，添加指定的金额。
    这将返回一个LocalTime，基于此，在单元的添加量。如果它是不可能添加的量，因为该单元不支持或其他原因，则抛出异常。
    
    如果该字段是ChronoUnit然后添加在这里实现。所支持的字段如下：
    - NANOS -返回一个与指定数纳秒LocalTime添加。这相当于plusNanos(long)。
    - MICROS返回具有指定的微秒数LocalTime添加。这是相当的金额乘以1000 plusNanos(long)。
    - MILLIS返回与指定的毫秒数LocalTime添加。这是相当的金额乘以1000000 plusNanos(long)。
    - SECONDS -返回与指定的秒数LocalTime添加。这相当于plusSeconds(long)。
    - MINUTES -返回与指定的分钟数LocalTime添加。这相当于plusMinutes(long)。
    - HOURS -返回与指定的小时数增加LocalTime。这相当于plusHours(long)。
    - HALF_DAYS -返回与指定数目的一半天LocalTime添加。这相当于plusHours(long)的金额乘以12。
    所有其他ChronoUnit实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoUnit，然后通过调用作为参数传递this TemporalUnit.addTo(Temporal, long)得到此方法的结果。在这种情况下，该单元确定是否和如何执行加法。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    plus 接口 Temporal
    
    参数
    
    amountToAdd -单位的数量增加的结果，可能是负面的
    
    unit -量的单位添加，不为空
    
    结果
    
    基于这一 LocalTime时间与指定的添加量，不为空
    
    异常
    
    DateTimeException如果还不能
    
    UnsupportedTemporalTypeException如果单位不支持
    
    ArithmeticException如果数值溢出时
  - plusHours
```
public LocalTime plusHours(long hoursToAdd)
```
    返回一份本 LocalTime在指定时间内添加时间。
    这增加了指定的时间数，以这个时间，返回一个新的时间。计算环绕午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hoursToAdd -添加时间，可能是负面的
    
    结果
    
    基于这一 LocalTime时间随着时间增加，不为空
  - plusMinutes
```
public LocalTime plusMinutes(long minutesToAdd)
```
    返回一份本 LocalTime在几分钟之内指定期间补充。
    这增加了指定的数分钟到这个时间，返回一个新的时间。计算环绕午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minutesToAdd -添加记录，可能是负面的
    
    结果
    
    一个 LocalTime基于此时间与增加分钟，不空
  - plusSeconds
```
public LocalTime plusSeconds(long secondstoAdd)
```
    返回一份本 LocalTime在指定时间内增加秒。
    这增加了指定的秒数，返回一个新的时间。计算环绕午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    secondstoAdd -加秒，可能是负面的
    
    结果
    
    一个 LocalTime基于此时间与秒说，不空
  - plusNanos
```
public LocalTime plusNanos(long nanosToAdd)
```
    返回一份本 LocalTime在纳秒指定期间补充。
    这增加了指定数纳秒到这个时候，返回一个新的时间。计算环绕午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanosToAdd -添加纳米，可能是负面的
    
    结果
    
    基于这一 LocalTime时间在纳秒补充道，不空
  - minus
```
public LocalTime minus(TemporalAmount amountToSubtract)
```
    返回此时间的副本与指定的金额减去。
    这将返回一个LocalTime，在此基础上，用指定的金额减去。量通常是Duration但可能是任何其他类型的TemporalAmount接口实现。
    
    计算委托量对象通过调用TemporalAmount.subtractFrom(Temporal)数量，实现自由以任何方式希望实现减法，但它通常需要回minus(long, TemporalUnit)。咨询文档的量的实现，以确定它是否可以成功地减去。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus 接口 Temporal
    
    参数
    
    amountToSubtract -减去的量，不为空
    
    结果
    
    一个 LocalTime基于这一次减法，不空
    
    异常
    
    DateTimeException如果减法不能做
    
    ArithmeticException如果数值溢出时
  - minus
```
public LocalTime minus(long amountToSubtract,
                       TemporalUnit unit)
```
    返回此时间的副本与指定的金额减去。
    这将返回一个LocalTime，在此基础上，对单位金额减去。如果它是不可能的减去的量，因为该单位不支持或一些其他原因，一个异常被抛出。
    
    这种方法是相当的金额plus(long, TemporalUnit)否定。见该方法充分说明了如何加法，从而减法，作品。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus 接口 Temporal
    
    参数
    
    amountToSubtract -减去从结果数额的单位，可能是负面的
    
    unit -金额单位减，不为空
    
    结果
    
    基于这一 LocalTime时间与指定的金额减去，不空
    
    异常
    
    DateTimeException如果减法不能做
    
    UnsupportedTemporalTypeException如果单位不支持
    
    ArithmeticException如果数值溢出时
  - minusHours
```
public LocalTime minusHours(long hoursToSubtract)
```
    返回一份本 LocalTime减去指定的时间在小时。
    这中减去指定的小时数从这个时间，返回一个新的时间。计算环绕午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hoursToSubtract -减小时，可能是负面的
    
    结果
    
    一个 LocalTime基于此时间与时间中减去，不空
  - minusMinutes
```
public LocalTime minusMinutes(long minutesToSubtract)
```
    返回一份本 LocalTime在几分钟之内减去指定的时间。
    这中减去指定的分钟数，从这个时候起，返回一个新的时间。计算环绕午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minutesToSubtract -减分，可能是负面的
    
    结果
    
    基于这一 LocalTime时间以分钟减去，不空
  - minusSeconds
```
public LocalTime minusSeconds(long secondsToSubtract)
```
    返回一份本 LocalTime与指定期秒减去。
    这中减去指定的秒数，从这个时候起，返回一个新的时间。计算环绕午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    secondsToSubtract -减去秒，可能是负面的
    
    结果
    
    一个 LocalTime基于此时间与秒减去，不空
  - minusNanos
```
public LocalTime minusNanos(long nanosToSubtract)
```
    返回一份本 LocalTime减去指定的时间在纳秒。
    这将指定数纳秒从这个时间，返回一个新的时间。计算环绕午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanosToSubtract -减去这些可能是负面的
    
    结果
    
    基于这一 LocalTime时间在纳秒减去，不空
  - 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作为现场。
    
    在大多数情况下，更清晰的用Temporal.with(TemporalAdjuster)反向调用模式：
```
这两条线是等价的，但第二种方法是建议时间= thislocaltime adjustinto（时间）；时间=（thislocaltime）与时间；
```
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    adjustInto 接口 TemporalAdjuster
    
    参数
    
    temporal -调整目标对象，不为空
    
    结果
    
    调整后的对象，而不是空
    
    异常
    
    DateTimeException如果无法适应
    
    ArithmeticException如果数值溢出时
  - until
```
public long until(Temporal endExclusive,
                  TemporalUnit unit)
```
    计算时间的量，直到另一个时间在指定的单位。
    这两LocalTime计算对象之间的时间量在一个TemporalUnit条款。开始和结束点this和指定的时间。结果将是负的，如果结束之前开始。的Temporal传递给此方法转换为LocalTime使用from(TemporalAccessor)。例如，在两次课时量可以计算出使用startTime.until(endTime, HOURS)。
    
    计算返回一个整数，表示两次之间的完全单位数。例如，在11:30和29之间的课时量将只有一个小时，因为它是短暂的两小时一分钟。
    
    使用这种方法有两个等效的方法。首先是调用这个方法。二是用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 -结束时间，排斥，这是转化为一个 LocalTime，不空
    
    unit -单位量来衡量，不为空
    
    结果
    
    这个时间和结束时间之间的时间
    
    异常
    
    DateTimeException如果金额无法计算，或结束时间不能转换为 LocalTime
    
    UnsupportedTemporalTypeException如果单位不支持
    
    ArithmeticException如果数值溢出时
  - format
```
public String format(DateTimeFormatter formatter)
```
    格式时使用指定的格式化程序。
    这一次将通过格式化程序产生一个字符串。
    
    参数
    
    formatter -格式化程序使用，不为空
    
    结果
    
    格式化的时间字符串，而不是空的
    
    异常
    
    DateTimeException如果打印时发生错误
  - atDate
```
public LocalDateTime atDate(LocalDate date)
```
    结合时间与日期创建一个 LocalDateTime。
    这会返回一个由这个时间在指定的日期LocalDateTime。日期和时间的所有可能的组合都是有效的。
    
    参数
    
    date -日期的结合，不为空
    
    结果
    
    从这个时间和指定日期形成的本地日期时间，而不是空
  - atOffset
```
public OffsetTime atOffset(ZoneOffset offset)
```
    结合这一次的偏移来创建一个 OffsetTime。
    返回由这个时间在指定偏移量OffsetTime。所有可能的时间和偏移的组合都是有效的。
    
    参数
    
    结合 offset偏移，不空
    
    结果
    
    从这个时间和指定的偏移量形成的偏移时间，而不是空值
  - toSecondOfDay
```
public int toSecondOfDay()
```
    提取时间为秒的日子，从 0到 24 * 60 * 60 - 1。
    
    结果
    
    第二天相当于这个时间
  - toNanoOfDay
```
public long toNanoOfDay()
```
    提取时间为3天，从 0到 24 * 60 * 60 * 1,000,000,000 - 1。
    
    结果
    
    这一天相当于这个时间
  - compareTo
```
public int compareTo(LocalTime other)
```
    比较这 LocalTime到另一个时间。
    比较是基于本地时间在一天内的时间线位置。这是“等于”一致，所定义的Comparable。
    
    Specified by:
    
    compareTo 接口 Comparable<LocalTime>
    
    参数
    
    other -相比其他时间，不空
    
    结果
    
    比较器的值，负的，如果少，积极的，如果更大
    
    异常
    
    NullPointerException -如果 other是空的
  - isAfter
```
public boolean isAfter(LocalTime other)
```
    如果这个检查 LocalTime是指定的时间后。
    该比较是基于在一天内的时间的时间线位置。
    
    参数
    
    other -相比其他时间，不空
    
    结果
    
    这是真的，如果这是在指定的时间
    
    异常
    
    NullPointerException -如果 other是空的
  - isBefore
```
public boolean isBefore(LocalTime other)
```
    如果这个检查是在规定的时间 LocalTime。
    该比较是基于在一天内的时间的时间线位置。
    
    参数
    
    other -相比其他时间，不空
    
    结果
    
    如果这一点是在指定的时间之前
    
    异常
    
    NullPointerException -如果 other是空的
  - equals
```
public boolean equals(Object obj)
```
    检查这个时间是否等于另一个时间。
    该比较是基于在一天内的时间的时间线位置。
    
    LocalTime型只有对象相比，其他类型返回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。
    输出将下列ISO-8601格式：
    - HH:mm
    - HH:mm:ss
    - HH:mm:ss.SSS
    - HH:mm:ss.SSSSSS
    - HH:mm:ss.SSSSSSSSS
    所用的格式将最短，输出的全部价值的时候，省略部分是暗示为零。
    重写：
    
    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 LocalTime

Field Summary

方法摘要

Methods inherited from class java.lang.Object

Field Detail

MIN

MAX

MIDNIGHT

NOON

方法详细信息

now

now

now

of

of

of

ofSecondOfDay

ofNanoOfDay

from

parse

parse

isSupported

isSupported

range

get

getLong

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

atOffset

toSecondOfDay

toNanoOfDay

compareTo

isAfter

isBefore

equals

hashCode

toString