实现的所有接口

Serializable ， Comparable<LocalTime> ， Temporal ， TemporalAccessor ， TemporalAdjuster
```
public final class LocalTime
extends Object
implements Temporal, TemporalAdjuster, Comparable<LocalTime>, Serializable
```
ISO- 10:15:30 ，例如10:15:30 。
LocalTime是一个不可变的日期时间对象，表示一个时间，通常被视为小时 - 秒 - 秒。时间表示为纳秒精度。例如，值“13：45.30.123456789”可以存储在LocalTime 。

此类不存储或表示日期或时区。相反，它是对挂钟上所见的当地时间的描述。如果没有附加信息（如偏移或时区），它不能代表时间线上的瞬间。

ISO-8601日历系统是当今世界大部分地区使用的现代民用日历系统。此API假定所有日历系统使用相同的表示形式，即此类，用于时间。

这是一个value-based班; 在LocalTime实例上使用身份敏感操作（包括引用相等（ == ），标识哈希码或同步）可能会产生不可预测的结果，应该避免使用。应使用equals方法进行比较。

实现要求：

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

从以下版本开始：

1.8

另请参见：

Serialized Form

字段汇总

字段
变量和类型	字段	描述
`static LocalTime`	`MAX`	支持的最大值为 `LocalTime` ，'23：59：59.999999999'。
`static LocalTime`	`MIDNIGHT`	一天开始时的午夜时间'00：00'。
`static LocalTime`	`MIN`	最低支持 `LocalTime` ，'00：00'。
`static LocalTime`	`NOON`	中午的时间是'12：00'。

方法摘要

所有方法静态方法实例方法具体的方法
变量和类型	方法	描述
`Temporal`	`adjustInto(Temporal temporal)`	调整指定的时态对象以使其与此对象具有相同的时间。
`LocalDateTime`	`atDate(LocalDate date)`	将此时间与日期相结合以创建 `LocalDateTime` 。
`OffsetTime`	`atOffset(ZoneOffset offset)`	将此时间与偏移量组合以创建 `OffsetTime` 。
`int`	`compareTo(LocalTime other)`	比较这个时间到另一个时间。
`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)`	检查此时间是否在指定时间之后。
`boolean`	`isBefore(LocalTime other)`	检查此时间是否在指定时间之前。
`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`	`ofInstant(Instant instant, ZoneId zone)`	从 `Instant`和区域ID获得 `LocalTime`的实例。
`static LocalTime`	`ofNanoOfDay(long nanoOfDay)`	从 `LocalTime`日值获得 `LocalTime`的实例。
`static LocalTime`	`ofSecondOfDay(long secondOfDay)`	从第二天的值获得 `LocalTime`的实例。
`static LocalTime`	`parse(CharSequence text)`	从文本字符串（例如 `10:15`获取 `LocalTime`的实例。
`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`添加了指定的纳秒数。
`LocalTime`	`plusSeconds(long secondstoAdd)`	返回此 `LocalTime`的副本，并添加指定的秒数。
`<R> R`	`query(TemporalQuery<R> query)`	这次使用指定的查询进行查询。
`ValueRange`	`range(TemporalField field)`	获取指定字段的有效值范围。
`long`	`toEpochSecond(LocalDate date, ZoneOffset offset)`	将此 `LocalTime`转换为自1970-01-01T00：00：00Z时代以来的秒数。
`long`	`toNanoOfDay()`	从 `0`到 `24 * 60 * 60 * 1,000,000,000 - 1` ，将时间提取为每天的 `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`的副本，并在第二分钟更改。

声明方法的类 java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- 字段详细信息
  - 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的 second
    
    结果
    
    当地时间，不是空的
    
    异常
    
    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到999,999,999
    
    结果
    
    当地时间，不是空的
    
    异常
    
    DateTimeException - 如果任何字段的值超出范围
  - ofInstant
```
public static LocalTime ofInstant(Instant instant,
                                  ZoneId zone)
```
    从Instant和区域ID获得LocalTime的实例。
    这将根据指定的时刻创建本地时间。首先，使用区域ID和瞬间获得UTC /格林威治的偏移量，这很简单，因为每个瞬间只有一个有效偏移量。然后，使用instant和offset来计算本地时间。
    
    参数
    
    instant - 创建时间的瞬间，而不是null
    
    zone - 时区，可以是偏移量，不为空
    
    结果
    
    当地时间，不是空的
    
    从以下版本开始：
    
    9
  - ofSecondOfDay
```
public static LocalTime ofSecondOfDay(long secondOfDay)
```
    从第二天的值获得LocalTime的实例。
    这将返回具有指定的第二天的LocalTime 。纳秒字段将设置为零。
    
    参数
    
    secondOfDay - 第二天，从 0到 24 * 60 * 60 - 1
    
    结果
    
    当地时间，不是空的
    
    异常
    
    DateTimeException - 如果第二天的值无效
  - ofNanoOfDay
```
public static LocalTime ofNanoOfDay(long nanoOfDay)
```
    从nanos-of-day值获得LocalTime的实例。
    这将返回具有指定纳秒数的LocalTime 。
    
    参数
    
    nanoOfDay - 纳米日，从 0到 24 * 60 * 60 * 1,000,000,000 - 1
    
    结果
    
    当地时间，不是空的
    
    异常
    
    DateTimeException - 如果 DateTimeException日值无效
  - from
```
public static LocalTime from(TemporalAccessor temporal)
```
    从时态对象获得LocalTime的实例。
    这基于指定的时间获得本地时间。 TemporalAccessor表示一组任意日期和时间信息，该工厂将其转换为LocalTime的实例。
    
    转换使用TemporalQueries.localTime()查询，该查询依赖于提取NANO_OF_DAY字段。
    
    该方法匹配功能接口TemporalQuery的签名，允许其通过方法参考LocalTime::from用作查询。
    
    参数
    
    temporal - 要转换的时态对象，而不是null
    
    结果
    
    当地时间，不是空的
    
    异常
    
    DateTimeException - 如果无法转换为 LocalTime
  - parse
```
public static LocalTime parse(CharSequence text)
```
    从文本字符串（例如10:15获取LocalTime的实例。
    该字符串必须表示有效时间，并使用DateTimeFormatter.ISO_LOCAL_TIME进行解析。
    
    参数
    
    text - 要解析的文本，例如“10:15:30”，而不是null
    
    结果
    
    解析的本地时间，不为空
    
    异常
    
    DateTimeParseException - 如果无法解析文本
  - parse
```
public static LocalTime parse(CharSequence text,
                              DateTimeFormatter formatter)
```
    使用特定格式化程序从文本字符串中获取LocalTime的实例。
    使用格式化程序解析文本，返回时间。
    
    参数
    
    text - 要解析的文本，而不是null
    
    formatter - 要使用的格式化程序，而不是null
    
    结果
    
    解析的本地时间，不为空
    
    异常
    
    DateTimeParseException - 如果无法解析文本
  - isSupported
```
public boolean isSupported(TemporalField field)
```
    检查是否支持指定的字段。
    这将检查是否可以查询指定字段的时间。如果是假，然后调用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
    
    参数
    
    字段 - 要检查的字段，null返回false
    
    结果
    
    如果此时支持该字段，则为true，否则为false
  - isSupported
```
public boolean isSupported(TemporalUnit unit)
```
    检查指定的单元是否受支持。
    这将检查此时是否可以添加或减去指定的单位。如果为false，则调用plus(long, TemporalUnit)和minus方法将引发异常。
    
    如果单位是ChronoUnit，则在此处执行查询。支持的单位是：
    
    NANOS
    
    MICROS
    
    MILLIS
    
    SECONDS
    
    MINUTES
    
    HOURS
    
    HALF_DAYS
    
    所有其他ChronoUnit实例将返回false。
    如果该单元不是ChronoUnit ，则此方法的结果是通过调用获得TemporalUnit.isSupportedBy(Temporal)传递this作为参数。设备是否受支持由设备决定。
    Specified by:
    
    isSupported在界面 Temporal
    
    参数
    
    unit - 要检查的单位，null返回false
    
    结果
    
    如果可以添加/减去单位，则为true，否则为false
  - range
```
public ValueRange range(TemporalField field)
```
    获取指定字段的有效值范围。
    范围对象表示字段的最小和最大有效值。此时间用于提高返回范围的准确性。如果无法返回范围，因为不支持该字段或由于某些其他原因，将引发异常。
    
    如果该字段是ChronoField，则在此处实现查询。 supported fields将返回适当的范围实例。所有其他ChronoField实例将抛出UnsupportedTemporalTypeException 。
    
    如果该字段不是ChronoField ，则通过调用this作为参数调用TemporalField.rangeRefinedBy(TemporalAccessor)获得此方法的结果。是否可以获得范围由该字段确定。
    
    Specified by:
    
    range在界面 TemporalAccessor
    
    参数
    
    字段 - 要查询范围的字段，而不是null
    
    结果
    
    字段的有效值范围，不为null
    
    异常
    
    DateTimeException - 如果无法获得该字段的范围
    
    UnsupportedTemporalTypeException - 如果不支持该字段
  - get
```
public int get(TemporalField field)
```
    从int获取此时指定字段的值。
    这次查询指定字段的值。返回的值将始终在该字段的有效值范围内。如果无法返回该值，因为不支持该字段或由于某些其他原因，将引发异常。
    
    如果该字段是ChronoField，则在此处执行查询。 supported fields将根据此时间返回有效值，但NANO_OF_DAY和MICRO_OF_DAY除外，它们太大而无法放入int并抛出UnsupportedTemporalTypeException 。所有其他ChronoField实例将抛出UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用获得TemporalField.getFrom(TemporalAccessor)传递this作为参数。是否可以获得该值以及该值表示的值由该字段确定。
    
    Specified by:
    
    get在界面 TemporalAccessor
    
    参数
    
    字段 - 要获取的字段，而不是null
    
    结果
    
    该字段的值
    
    异常
    
    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
    
    参数
    
    字段 - 要获取的字段，而不是null
    
    结果
    
    该字段的值
    
    异常
    
    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到999,999,999
  - with
```
public LocalTime with(TemporalAdjuster adjuster)
```
    返回此时的调整副本。
    这将返回一个LocalTime ，基于此，调整时间。使用指定的调整器策略对象进行调整。阅读调整器的文档，了解将进行哪些调整。
    
    简单的调整器可能只是设置其中一个字段，例如小时字段。更复杂的调节器可能会将时间设置为当天的最后一小时。
    
    此方法的结果是通过调用获得TemporalAdjuster.adjustInto(Temporal)在经过指定的调节方法this作为参数。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    with在界面 Temporal
    
    参数
    
    adjuster - 要使用的调整器，不为null
    
    结果
    
    a LocalTime基于 this并进行了调整，而不是null
    
    异常
    
    DateTimeException - 如果无法进行调整
    
    ArithmeticException - 如果发生数字溢出
  - with
```
public LocalTime with(TemporalField field,
                      long newValue)
```
    返回此时间的副本，并将指定字段设置为新值。
    这将返回LocalTime （基于此值），并更改指定字段的值。这可用于更改任何支持的字段，例如小时，分钟或秒。如果无法设置该值，因为不支持该字段或由于某些其他原因，将引发异常。
    
    如果该字段是ChronoField，则在此处执行调整。支持的字段表现如下：
    
    NANO_OF_SECOND - 返回具有指定的LocalTime级的LocalTime 。小时，分钟和秒将保持不变。
    
    NANO_OF_DAY - 返回具有指定纳米天数的LocalTime 。这完全取代了时间，相当于ofNanoOfDay(long) 。
    
    MICRO_OF_SECOND - 返回LocalTime ，其中纳秒数由指定的微秒乘以1,000替换。小时，分钟和秒将保持不变。
    
    MICRO_OF_DAY - 返回具有指定微日的LocalTime 。这完全取代了时间，相当于使用ofNanoOfDay(long) ，微天数乘以1,000。
    
    MILLI_OF_SECOND - 返回LocalTime ，其中纳秒数由指定的毫秒乘以1,000,000替换。小时，分钟和秒将保持不变。
    
    MILLI_OF_DAY - 返回具有指定毫秒数的LocalTime 。这完全取代了时间，相当于使用ofNanoOfDay(long) ，毫秒乘以1,000,000。
    
    SECOND_OF_MINUTE - 以指定的LocalTime返回LocalTime 。小时，分钟和纳秒将保持不变。
    
    SECOND_OF_DAY - 返回指定的第二天的LocalTime 。纳秒将保持不变。
    
    MINUTE_OF_HOUR - 返回指定分钟数的LocalTime 。小时，秒，秒和纳秒将保持不变。
    
    MINUTE_OF_DAY - 返回指定分钟的LocalTime 。第二分钟和纳秒将保持不变。
    
    HOUR_OF_AMPM - 返回一个LocalTime其中包含指定的上午小时。 AM / PM，分钟，分钟和纳秒将保持不变。
    
    CLOCK_HOUR_OF_AMPM - 返回一个指定的clock-hour-am-pm的LocalTime 。 AM / PM，分钟，分钟和纳秒将保持不变。
    
    HOUR_OF_DAY - 返回指定时间的LocalTime 。分钟，秒和纳秒将保持不变。
    
    CLOCK_HOUR_OF_DAY - 返回具有指定时钟 - 小时的LocalTime 。分钟，秒和纳秒将保持不变。
    
    AMPM_OF_DAY - 返回带有指定AM / PM的LocalTime 。上午小时，分钟，分钟秒和纳秒将保持不变。
    
    在所有情况下，如果新值超出该字段的有效值范围，则将抛出DateTimeException 。
    
    所有其他ChronoField实例将抛出UnsupportedTemporalTypeException 。
    
    如果该字段不是ChronoField ，则通过调用TemporalField.adjustInto(Temporal, long)传递this作为参数来获得此方法的结果。在这种情况下，该字段确定是否以及如何调整瞬间。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    with ，界面 Temporal
    
    参数
    
    字段 - 要在结果中设置的字段，不为null
    
    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 - 在结果中设置的 second ，从0到59
    
    结果
    
    基于此时间的 LocalTime与请求的秒，不为空
    
    异常
    
    DateTimeException - 如果第二个值无效
  - withNano
```
public LocalTime withNano(int nanoOfSecond)
```
    返回此LocalTime的副本，其中纳秒级已更改。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanoOfSecond - 在结果中设置的纳秒数，从0到999,999,999
    
    结果
    
    基于此时间的 LocalTime ，请求纳秒，不为空
    
    异常
    
    DateTimeException - 如果nanos值无效
  - truncatedTo
```
public LocalTime truncatedTo(TemporalUnit unit)
```
    返回此LocalTime的副本，并截断时间。
    截断返回原始时间的副本，其中小于指定单位的字段设置为零。例如，使用minutes单位截断将第二分钟和纳秒级字段设置为零。
    
    该单位必须有一个duration ，它分为标准日的长度，没有余数。这包括ChronoUnit和DAYS上提供的所有时间单位。其他单位抛出异常。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    unit - 要截断的单位，而不是null
    
    结果
    
    基于此时间的 LocalTime ，截断时间，不为空
    
    异常
    
    DateTimeException - 如果无法截断
    
    UnsupportedTemporalTypeException - 如果不支持该装置
  - plus
```
public LocalTime plus(TemporalAmount amountToAdd)
```
    返回此时间的副本，并添加指定的数量。
    这将返回基于此值的LocalTime ，并添加指定的数量。金额通常为Duration，但可以是实现TemporalAmount界面的任何其他类型。
    
    通过调用TemporalAmount.addTo(Temporal)将计算委托给amount对象。实施金额可以任意方式自由实施，但通常会回拨给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 ，其中添加了指定的微秒数。这相当于plusNanos(long) ，金额乘以1,000。
    
    MILLIS - 返回一个LocalTime ，其中添加了指定的毫秒数。这相当于plusNanos(long) ，金额乘以1,000,000。
    
    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的副本， LocalTime添加了指定的纳秒数。
    这会在此时添加指定的纳秒数，从而返回新的时间。计算在午夜左右。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanosToAdd - 要添加的 nanosToAdd ，可能是负面的
    
    结果
    
    基于此时间的 LocalTime ，加上纳秒，不为空
  - minus
```
public LocalTime minus(TemporalAmount amountToSubtract)
```
    返回此时间的副本，并减去指定的数量。
    这将返回一个LocalTime ，基于此值，减去指定的数量。金额通常为Duration，但可能是实现TemporalAmount界面的任何其他类型。
    
    通过调用TemporalAmount.subtractFrom(Temporal)将计算委托给amount对象。实现量可以以任何方式自由地实现减法，但是它通常会回调到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 - 要减去的 nanosToSubtract ，可能是负的
    
    结果
    
    基于此时间的 LocalTime减去纳秒，而不是空
  - query
```
public <R> R query(TemporalQuery<R> query)
```
    这次使用指定的查询进行查询。
    这次使用指定的查询策略对象进行查询。 TemporalQuery对象定义用于获取结果的逻辑。阅读查询文档以了解此方法的结果。
    
    通过在指定的查询上调用TemporalQuery.queryFrom(TemporalAccessor)方法作为参数传递this来获得此方法的结果。
    
    Specified by:
    
    query在界面 TemporalAccessor
    
    参数类型
    
    R - 结果的类型
    
    参数
    
    query - 要调用的查询，而不是null
    
    结果
    
    查询结果，可以返回null（由查询定义）
    
    异常
    
    DateTimeException - 如果无法查询（由查询定义）
    
    ArithmeticException - 如果发生数字溢出（由查询定义）
  - adjustInto
```
public Temporal adjustInto(Temporal temporal)
```
    调整指定的时态对象以使其与此对象具有相同的时间。
    这将返回与输入相同的可观察类型的时间对象，并将时间更改为与此相同。
    
    该调整是相当于使用Temporal.with(TemporalField, long)传递ChronoField.NANO_OF_DAY作为字段。
    
    在大多数情况下，使用Temporal.with(TemporalAdjuster)更清楚地反转调用模式：
    
    // these two lines are equivalent, but the second approach is recommended temporal = thisLocalTime.adjustInto(temporal); temporal = temporal.with(thisLocalTime);
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    adjustInto在界面 TemporalAdjuster
    
    参数
    
    temporal - 要调整的目标对象，而不是null
    
    结果
    
    调整后的对象，不为空
    
    异常
    
    DateTimeException - 如果无法进行调整
    
    ArithmeticException - 如果发生数字溢出
  - until
```
public long until(Temporal endExclusive,
                  TemporalUnit unit)
```
    根据指定的单位计算到另一个时间的时间量。
    这将根据单个TemporalUnit计算两个LocalTime对象之间的时间量。起点和终点是this和指定的时间。如果结束在开始之前，结果将是否定的。所述Temporal传递给此方法被转换为LocalTime使用from(TemporalAccessor) 。例如，可以使用startTime.until(endTime, HOURS)计算两次之间的小时startTime.until(endTime, HOURS) 。
    
    计算返回一个整数，表示两次之间的完整单位数。例如，11：30到13:29之间的小时数仅为1小时，因为它是两小时的一分钟。
    
    使用此方法有两种等效方法。第一种是调用此方法。第二种是使用TemporalUnit.between(Temporal, Temporal) ：
    
    // these two lines are equivalent amount = start.until(end, MINUTES); amount = MINUTES.between(start, end);
    应该根据哪个使代码更具可读性来做出选择。
    该计算在ChronoUnit的此方法中实施。单位NANOS ， MICROS ， MILLIS ， SECONDS ， MINUTES ， HOURS和HALF_DAYS支持。其他ChronoUnit值将引发异常。
    
    如果单位不是ChronoUnit ，则通过调用this作为第一个参数并将转换后的输入temporal作为第二个参数，获得TemporalUnit.between(Temporal, Temporal)获得此方法的结果。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    until ，界面 Temporal
    
    参数
    
    endExclusive - 结束时间，独占，转换为 LocalTime ，不为空
    
    unit - 计量金额的单位，而不是空
    
    结果
    
    此时间与结束时间之间的时间量
    
    异常
    
    DateTimeException - 如果金额无法计算，或结束时间不能转换为 LocalTime
    
    UnsupportedTemporalTypeException - 如果不支持该单元
    
    ArithmeticException - 如果发生数字溢出
  - format
```
public String format(DateTimeFormatter formatter)
```
    这次使用指定的格式化程序格式化。
    此时间将传递给格式化程序以生成字符串。
    
    参数
    
    formatter - 要使用的格式化程序，不为null
    
    结果
    
    格式化的时间字符串，不为空
    
    异常
    
    DateTimeException - 如果在打印期间发生错误
  - atDate
```
public LocalDateTime atDate(LocalDate date)
```
    将此时间与日期相结合以创建LocalDateTime 。
    这将返回在此时间在指定日期形成的LocalDateTime 。所有可能的日期和时间组合均有效。
    
    参数
    
    date - 要结合的日期，而不是null
    
    结果
    
    从此时间和指定日期形成的本地日期时间，不为空
  - atOffset
```
public OffsetTime atOffset(ZoneOffset offset)
```
    将此时间与偏移量组合以创建OffsetTime 。
    这将返回从此时间在指定偏移量处形成的OffsetTime 。所有可能的时间和偏移组合都是有效的。
    
    参数
    
    offset - 要与之结合的偏移量，而不是null
    
    结果
    
    从此时间和指定的偏移量形成的偏移时间，不为空
  - toSecondOfDay
```
public int toSecondOfDay()
```
    将时间提取为一天中的秒数，从 0到 24 * 60 * 60 - 1 。
    
    结果
    
    相当于这个时间的第二天
  - toNanoOfDay
```
public long toNanoOfDay()
```
    从 0到 24 * 60 * 60 * 1,000,000,000 - 1 ，将时间提取为 24 * 60 * 60 * 1,000,000,000 - 1 。
    
    结果
    
    相当于这个时间的纳米日
  - toEpochSecond
```
public long toEpochSecond(LocalDate date,
                          ZoneOffset offset)
```
    将此LocalTime转换为自1970-01-01T00：00：00Z时代以来的秒数。
    这将此本地时间与指定的日期和偏移量组合以计算纪元秒数值，该值是1970-01-01T00：00：00Z的经过秒数。在时代之后的时间线上的实例是正的，之前是负的。
    
    参数
    
    date - 本地日期，不为空
    
    offset - 区域偏移量，不为空
    
    结果
    
    自1970-01-01T00：00：00Z时代以来的秒数可能是负数
    
    从以下版本开始：
    
    9
  - compareTo
```
public int compareTo(LocalTime other)
```
    比较这个时间到另一个时间。
    比较基于一天内当地时间的时间线位置。它与“等于”一致，如Comparable所定义。
    
    Specified by:
    
    compareTo在界面 Comparable<LocalTime>
    
    参数
    
    other - 要比较的另一个时间，而不是null
    
    结果
    
    比较器值，如果更小则为负，如果更大则为正
  - isAfter
```
public boolean isAfter(LocalTime other)
```
    检查此时间是否在指定时间之后。
    比较基于一天内时间的时间线位置。
    
    参数
    
    other - 另一个要比较的时间，而不是null
    
    结果
    
    如果在指定时间之后，则返回true
  - isBefore
```
public boolean isBefore(LocalTime other)
```
    检查此时间是否在指定时间之前。
    比较基于一天内时间的时间线位置。
    
    参数
    
    other - 要比较的另一个时间，而不是null
    
    结果
    
    如果此点在指定时间之前，则为true
  - equals
```
public boolean equals(Object obj)
```
    检查此时间是否等于另一个时间。
    比较基于一天内时间的时间线位置。
    
    仅比较类型为LocalTime对象，其他类型返回false。要比较两个TemporalAccessor实例的日期，请使用ChronoField.NANO_OF_DAY作为比较器。
    
    重写：
    
    equals ，课程 Object
    
    参数
    
    obj - 要检查的对象，null返回false
    
    结果
    
    如果这等于另一个时间，则为true
    
    另请参见：
    
    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
    
    结果
    
    此时的字符串表示形式，不为null

Class LocalTime

字段汇总

方法摘要

声明方法的类 java.lang.Object

字段详细信息

MIN

MAX

MIDNIGHT

NOON

方法详细信息

now

now

now

of

of

of

ofInstant

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

toEpochSecond

compareTo

isAfter

isBefore

equals

hashCode

toString