ChronoField (Java Platform SE 8 )

java.lang.Object
- java.lang.Enum<ChronoField>
- - java.time.temporal.ChronoField

All Implemented Interfaces:

Serializable， Comparable < ChronoField >， TemporalField
```
public enum ChronoField
extends Enum<ChronoField>
implements TemporalField
```
一组标准的字段。
这一组字段提供了基于字段的访问来操作日期、时间或日期时间。领域的标准可以通过实施TemporalField扩展。

这些字段的目的是适用于多个日历系统。例如，大多数非同一日历系统定义日期为一年，一个月和一天，只是有轻微的不同的规则。每个字段的文档解释了它是如何操作的。

实现要求：

这是最终的，不变的，线程安全的枚举。

从以下版本开始：

一点八

Enum Constant Summary

Enum Constants
Enum Constant and Description
`ALIGNED_DAY_OF_WEEK_IN_MONTH` 一个月内一周的排列。
`ALIGNED_DAY_OF_WEEK_IN_YEAR` 一年内一周的对齐。
`ALIGNED_WEEK_OF_MONTH` 一个月内对齐的一周。
`ALIGNED_WEEK_OF_YEAR` 一年内对齐的一周。
`AMPM_OF_DAY` 当天上午的下午。
`CLOCK_HOUR_OF_AMPM` 上午上午的时钟。
`CLOCK_HOUR_OF_DAY` 一天中的时钟。
`DAY_OF_MONTH` 月之日。
`DAY_OF_WEEK` 一周的一天，如星期二。
`DAY_OF_YEAR` 年的一天。
`EPOCH_DAY` 时代天，基于1970-01-01 java时代（ISO）。
`ERA` 时代。
`HOUR_OF_AMPM` 上午下午的时间。
`HOUR_OF_DAY` 一天一个小时。
`INSTANT_SECONDS` 瞬间时代秒。
`MICRO_OF_DAY` 微观的一天。
`MICRO_OF_SECOND` 微观第二。
`MILLI_OF_DAY` 天毫。
`MILLI_OF_SECOND` 二毫。
`MINUTE_OF_DAY` 一天的每一分钟。
`MINUTE_OF_HOUR` 小时的分钟。
`MONTH_OF_YEAR` 一年中的一个月，如3月。
`NANO_OF_DAY` 纳米日。
`NANO_OF_SECOND` 第二纳米。
`OFFSET_SECONDS` 从UTC偏移/格林尼治。
`PROLEPTIC_MONTH` 预期月为主，计数顺序从一年0个月。
`SECOND_OF_DAY` 第二天。
`SECOND_OF_MINUTE` 第二分钟。
`YEAR` 预期的一年，如2012。
`YEAR_OF_ERA` 时代的一年。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	Method and Description
`<R extends Temporal> R`	`adjustInto(R temporal, long newValue)` 返回一个指定的时间对象的副本，此字段集的值为。
`int`	`checkValidIntValue(long value)` 检查指定的值是有效的，适合在一个 `int`。
`long`	`checkValidValue(long value)` 检查指定的值对该字段是否有效。
`TemporalUnit`	`getBaseUnit()` 获取字段的单位，该字段在。
`String`	`getDisplayName(Locale locale)` 获取所请求的区域设置中的字段的显示名称。
`long`	`getFrom(TemporalAccessor temporal)` 从指定的时间对象中获取此字段的值。
`TemporalUnit`	`getRangeUnit()` 获取字段所绑定的范围。
`boolean`	`isDateBased()` 检查此字段是否代表日期的一个组件。
`boolean`	`isSupportedBy(TemporalAccessor temporal)` 检查此字段是否被时间对象支持。
`boolean`	`isTimeBased()` 检查此字段是否表示时间的一个组件。
`ValueRange`	`range()` 获取字段的有效值的范围。
`ValueRange`	`rangeRefinedBy(TemporalAccessor temporal)` 获取此字段的有效值的范围，使用时间对象来细化结果。
`String`	`toString()` 返回此枚举常量的名称，包含在声明。
`static ChronoField`	`valueOf(String name)` 返回此类型具有指定名称的枚举常量。
`static ChronoField[]`	`values()` 返回一个数组包含该枚举类型的常量，它们的顺序声明。

Methods inherited from class java.lang.Enum
clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, valueOf

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

Methods inherited from interface java.time.temporal.TemporalField
resolve

- Enum Constant Detail
  - NANO_OF_SECOND
```
public static final ChronoField NANO_OF_SECOND
```
    第二纳米。
    这计数纳秒内的第二，从0到999999999。此字段对所有日历系统都具有相同的含义。
    
    此字段是用来表示纳米第二处理任何分数的第二。实现TemporalAccessor如果他们可以返回一个值SECOND_OF_MINUTE提供该域的值，SECOND_OF_DAY或INSTANT_SECONDS填充未知的精密零。
    
    当这个字段用于设置一个值时，它应该设置尽可能多的精确的对象存储，使用整数除法，以消除多余的精度。例如，如果TemporalAccessor店时间精确到毫秒，然后第二纳米必须除以1000000才更换二毫。
    
    当解析此字段时，它的行为相当于以下内容：在严格的和智能的模式，但不在宽松模式下验证的值。这场与MILLI_OF_SECOND和MICRO_OF_SECOND组合解决。
  - NANO_OF_DAY
```
public static final ChronoField NANO_OF_DAY
```
    纳米日。
    这计数纳秒内的一天内，从0到（24 * 60 * 60 * 1000000000）- 1。此字段对所有日历系统都具有相同的含义。
    
    这个字段是用来表示纳米的一天处理任何部分的第二个。实现TemporalAccessor如果他们可以返回SECOND_OF_DAY零填充未知的精度值为该域的值。
    
    当解析此字段时，它的行为相当于以下内容：在严格的和智能的模式，但不在宽松模式下验证的值。价值分裂形成NANO_OF_SECOND，SECOND_OF_MINUTE，MINUTE_OF_HOUR和HOUR_OF_DAY领域。
  - MICRO_OF_SECOND
```
public static final ChronoField MICRO_OF_SECOND
```
    微观第二。
    这数微秒内次之，从0到999999。此字段对所有日历系统都具有相同的含义。
    
    这个字段是用来表示第二个处理任何部分的第二个。实现TemporalAccessor如果他们可以返回一个值SECOND_OF_MINUTE提供该域的值，SECOND_OF_DAY或INSTANT_SECONDS填充未知的精密零。
    
    当这场是用来设置一个值，它应该表现出同样的值乘以1000的设置NANO_OF_SECOND。
    
    当解析此字段时，它的行为相当于以下内容：在严格的和智能的模式，但不在宽松模式下验证的值。现场解决生产NANO_OF_SECOND结合MILLI_OF_SECOND。
  - MICRO_OF_DAY
```
public static final ChronoField MICRO_OF_DAY
```
    微观的一天。
    这数微秒内天，从0（24 * 60 * 60 * 1000000）- 1。此字段对所有日历系统都具有相同的含义。
    
    这个字段是用来表示每天处理的第二部分的任何部分。实现TemporalAccessor如果他们可以返回SECOND_OF_DAY零填充未知的精度值为该域的值。
    
    当这场是用来设置一个值，它应该表现出同样的值乘以1000的设置NANO_OF_DAY。
    
    当解析此字段时，它的行为相当于以下内容：在严格的和智能的模式，但不在宽松模式下验证的值。价值分裂形成MICRO_OF_SECOND，SECOND_OF_MINUTE，MINUTE_OF_HOUR和HOUR_OF_DAY领域。
  - MILLI_OF_SECOND
```
public static final ChronoField MILLI_OF_SECOND
```
    二毫。
    这在第二个数毫秒内，从0到999。此字段对所有日历系统都具有相同的含义。
    
    此字段是用来表示第二处理第二任何分数毫。实现TemporalAccessor如果他们可以返回一个值SECOND_OF_MINUTE提供该域的值，SECOND_OF_DAY或INSTANT_SECONDS填充未知的精密零。
    
    当这场是用来设置一个值，它应该表现出同样的值乘以1000000的设置NANO_OF_SECOND。
    
    当解析此字段时，它的行为相当于以下内容：在严格的和智能的模式，但不在宽松模式下验证的值。现场解决生产NANO_OF_SECOND结合MICRO_OF_SECOND。
  - MILLI_OF_DAY
```
public static final ChronoField MILLI_OF_DAY
```
    天毫。
    这在一天内的毫秒数，从0到（24 * 60 * 60 * 1000）- 1。此字段对所有日历系统都具有相同的含义。
    
    此字段是用来表示第二天处理任何分数毫。实现TemporalAccessor如果他们可以返回SECOND_OF_DAY零填充未知的精度值为该域的值。
    
    当这场是用来设置一个值，它应该表现出同样的值乘以1000000的设置NANO_OF_DAY。
    
    当解析此字段时，它的行为相当于以下内容：在严格的和智能的模式，但不在宽松模式下验证的值。价值分裂形成MILLI_OF_SECOND，SECOND_OF_MINUTE，MINUTE_OF_HOUR和HOUR_OF_DAY领域。
  - SECOND_OF_MINUTE
```
public static final ChronoField SECOND_OF_MINUTE
```
    第二分钟。
    这在一分钟内的第二个数，从0到59。此字段对所有日历系统都具有相同的含义。
    
    当解析此字段时，它的行为相当于以下内容：在严格的和智能的模式，但不在宽松模式下验证的值。
  - SECOND_OF_DAY
```
public static final ChronoField SECOND_OF_DAY
```
    第二天。
    这在一天内第二次计数，从0到（24 * 60 * 60）- 1。此字段对所有日历系统都具有相同的含义。
    
    当解析此字段时，它的行为相当于以下内容：在严格的和智能的模式，但不在宽松模式下验证的值。价值分裂形成SECOND_OF_MINUTE，MINUTE_OF_HOUR和HOUR_OF_DAY领域。
  - MINUTE_OF_HOUR
```
public static final ChronoField MINUTE_OF_HOUR
```
    小时的分钟。
    这在一小时内的分钟数，从0到59。此字段对所有日历系统都具有相同的含义。
    
    当解析此字段时，它的行为相当于以下内容：在严格的和智能的模式，但不在宽松模式下验证的值。
  - MINUTE_OF_DAY
```
public static final ChronoField MINUTE_OF_DAY
```
    一天的每一分钟。
    这在一天内的每分钟，从0到（24 * 60）- 1。此字段对所有日历系统都具有相同的含义。
    
    当解析此字段时，它的行为相当于以下内容：在严格的和智能的模式，但不在宽松模式下验证的值。价值分裂形成MINUTE_OF_HOUR和HOUR_OF_DAY领域。
  - HOUR_OF_AMPM
```
public static final ChronoField HOUR_OF_AMPM
```
    上午下午的时间。
    这就在上午/下午的时间内计算，从0点到11点。这是一个标准的12小时的数字时钟上观察到的一个小时。此字段对所有日历系统都具有相同的含义。
    
    当解析此字段时，它的行为相当于以下内容：在严格和智能模式下，从0到11的值进行了验证。在宽松模式下，价值没有被验证。它是结合AMPM_OF_DAY由{ ampm_of_day }值乘以12的形式HOUR_OF_DAY。
  - CLOCK_HOUR_OF_AMPM
```
public static final ChronoField CLOCK_HOUR_OF_AMPM
```
    上午上午的时钟。
    这就在上午/下午的时间内计算，从1点到12点。这是一个标准的12小时的模拟墙上时钟上观察到的一个小时。此字段对所有日历系统都具有相同的含义。
    
    当解析此字段时，它的行为相当于以下内容：从12到0的严格模式和智能模式从1到12的值进行了验证。在宽松模式下，价值没有被验证。字段转换为具有相同值的HOUR_OF_AMPM，除非该值为12，在这种情况下，它转换为0。
  - HOUR_OF_DAY
```
public static final ChronoField HOUR_OF_DAY
```
    一天一个小时。
    这在一天内的小时数，从0到23。这是一个标准的24小时数字时钟上观察到的一个小时。此字段对所有日历系统都具有相同的含义。
    
    当解析此字段时，它的行为相当于以下内容：在严格的和智能的模式，但不在宽松模式下验证的值。这场联合MINUTE_OF_HOUR，SECOND_OF_MINUTE和NANO_OF_SECOND产生LocalTime。在宽松的模式，任何多余的天添加到解析日期，或可以通过DateTimeFormatter.parsedExcessDays()。
  - CLOCK_HOUR_OF_DAY
```
public static final ChronoField CLOCK_HOUR_OF_DAY
```
    一天中的时钟。
    这就在上午/下午的时间内计算，从1点到24点。这是一个24小时的模拟墙上的时钟上观察到的一个小时。此字段对所有日历系统都具有相同的含义。
    
    当解析此字段时，它的行为相当于以下内容：从24到0的严格模式和智能模式从1到24的值进行了验证。在宽松模式下，价值没有被验证。字段转换为具有相同值的HOUR_OF_DAY，除非该值为24，在这种情况下，它转换为0。
  - AMPM_OF_DAY
```
public static final ChronoField AMPM_OF_DAY
```
    当天上午的下午。
    这项统计上午/下午在一天内，从上午0点（上午）到1（下午）。此字段对所有日历系统都具有相同的含义。
    
    当解析此字段时，它的行为相当于以下内容：在严格和智能模式下，从0到1的值进行了验证。在宽松模式下，价值没有被验证。它是结合HOUR_OF_AMPM由{ ampm_of_day }值乘以12的形式HOUR_OF_DAY。
  - DAY_OF_WEEK
```
public static final ChronoField DAY_OF_WEEK
```
    一周的一天，如星期二。
    这代表了一周的一天的标准概念。在默认的国际标准体系组织日历系统中，这一值从星期一（1）到星期日（7）。的DayOfWeek类可以用来解释的结果。
    
    大多数非同异的日历系统也定义了一七天的一周，与国际标准化组织。这些日历系统也必须使用相同的编号系统，从星期一到星期日（1）（7），它允许DayOfWeek用于。
    
    没有标准的七天的一周的日历系统应该实现这一领域，如果他们有一个类似的概念命名或编号天内一个周期类似一个星期。建议编号从1开始。
  - ALIGNED_DAY_OF_WEEK_IN_MONTH
```
public static final ChronoField ALIGNED_DAY_OF_WEEK_IN_MONTH
```
    一个月内一周的排列。
    这代表了一周内的天数的计数的概念，在一周的时间是一致的开始的月份。这场是典型的用ALIGNED_WEEK_OF_MONTH。
    
    例如，在一个一七天的一周的日历系统中，第一个对齐的一周月开始在1个月的一天，第二个对齐的一周开始在8个月的一天，等等。在每一个对齐的星期内，天数从1到7，并返回到这个字段的值。因此，月1日至7日的一天将有一天的价值观从1至7。月8日至14日将重复这一天的一周值从1到7。
    
    没有一七天的一周的日历系统通常应该以同样的方式实现这一字段，但使用备用的周长度。
  - ALIGNED_DAY_OF_WEEK_IN_YEAR
```
public static final ChronoField ALIGNED_DAY_OF_WEEK_IN_YEAR
```
    一年内一周的对齐。
    这代表了一周内的天数的计数的概念，其中几个星期与一年的开始是一致的。这场是典型的用ALIGNED_WEEK_OF_YEAR。
    
    例如，在一个日历系统的一七天周，第一次对齐的一周，一年1天开始，第二个对齐的一周开始在8年的一天，等等。在每一个对齐的星期内，天数从1到7，并返回到这个字段的值。因此，1至7天的一天将有一天的一周值从1到7。8至14天的一天将重复这一天，从1至7日的一周的价值观。
    
    没有一七天的一周的日历系统通常应该以同样的方式实现这一字段，但使用备用的周长度。
  - DAY_OF_MONTH
```
public static final ChronoField DAY_OF_MONTH
```
    月之日。
    这代表了一个月内的一天的概念。在默认的国际标准体系日历系统中，大多数月份的值从1到31。四月，六月，九月，十一月有天，从1到30，而二月有28至1天，或29，在一个飞跃年。
    
    非等日历系统应使用最公认的一个月的日历系统的用户价值来实现这一领域。通常情况下，这是一个从1天到月的天数。
  - DAY_OF_YEAR
```
public static final ChronoField DAY_OF_YEAR
```
    年的一天。
    这代表了一年内的一天的概念。在默认的国际标准化组织日历系统中，这一值从365到1，在标准年和1到366年的飞跃。
    
    非等日历系统应该使用一年中最被认可的日历系统的用户来实现这一字段。通常情况下，这是一个从1天到一年的时间。
    
    请注意，一个非等值的日历系统可能有一年的编号系统，在不同的点的自然重置在月编号。这方面的一个例子是日本的日历系统，其中一个变化的时代，从而复位年数为1，可在任何时间发生的。时代和年的复位也导致一年的一天被重置为1，但不是一个月或一天的一个月。
  - EPOCH_DAY
```
public static final ChronoField EPOCH_DAY
```
    时代天，基于1970-01-01 java时代（ISO）。
    这场是天1970-01-01顺序计数（ISO）为零。注意，使用地方的时间线，忽略偏移和时区。
    
    此字段被严格定义为在所有日历系统中都具有相同的含义。这是确保互操作日历。
  - ALIGNED_WEEK_OF_MONTH
```
public static final ChronoField ALIGNED_WEEK_OF_MONTH
```
    一个月内对齐的一周。
    这代表了一个月内的数周的计数的概念，在一个月内，几个星期是一致的开始的月份。这场是典型的用ALIGNED_DAY_OF_WEEK_IN_MONTH。
    
    例如，在一个一七天的一周的日历系统中，第一个对齐的一周月开始在1个月的一天，第二个对齐的一周开始在8个月的一天，等等。因此，月值1日至7日是在对齐的一周1，而一天的月值8日至14日是在对齐的一周2，等等。
    
    没有一七天的一周的日历系统通常应该以同样的方式实现这一字段，但使用备用的周长度。
  - ALIGNED_WEEK_OF_YEAR
```
public static final ChronoField ALIGNED_WEEK_OF_YEAR
```
    一年内对齐的一周。
    这代表了一年内的数周数的概念，在一年的时间内，几周是一致的，在一年的开始。这场是典型的用ALIGNED_DAY_OF_WEEK_IN_YEAR。
    
    例如，在一个日历系统的一七天周，第一次对齐的一周，一年1天开始，第二个对齐的一周开始在8年的一天，等等。因此，一年的价值1日至7日是在对齐的一周1，而一年的价值8日至14日是在对齐的一周2，等等。
    
    没有一七天的一周的日历系统通常应该以同样的方式实现这一字段，但使用备用的周长度。
  - MONTH_OF_YEAR
```
public static final ChronoField MONTH_OF_YEAR
```
    一年中的一个月，如3月。
    这代表了一年内一个月的概念。在默认的国际标准体系组织日历系统中，这值从一月（1）到十二月（12）。
    
    非等日历系统应该使用最被认可的一个月的日历系统的用户来实现这一领域。通常情况下，这是从1个月开始的计数。
  - PROLEPTIC_MONTH
```
public static final ChronoField PROLEPTIC_MONTH
```
    预期月为主，计数顺序从一年0个月。
    这场是个月，预期零年的第一个月有零值序列数。后个月有越来越大的价值观。前几个月有越来越小的价值观。在几个月的序列中没有缝隙或休息。注意，使用地方的时间线，忽略偏移和时区。
    
    在默认的ISO的日历系统，六月2012将有价值(2012 * 12 + 6 - 1)。这场主要是供内部使用。
    
    非等日历系统必须按照上面的定义实现这一字段。它只是一个简单的基于零的计数后的月从预期0年的开始。所有的日历系统与充分的预期年定义将有一年的零。如果日历系统具有一个不包括年零的最小年，则必须对该方法进行外推以确定该方法的定义。
  - YEAR_OF_ERA
```
public static final ChronoField YEAR_OF_ERA
```
    时代的一年。
    这代表了一年内的概念。这场是典型的用ERA。
    
    日期的标准心智模型是基于三个概念，一年，一个月和一天。这些Map上YEAR，MONTH_OF_YEAR和DAY_OF_MONTH领域。请注意，没有对时代的参考。一个日期的完整模型需要四个概念：时代、年、月和日。这些Map上ERA，YEAR_OF_ERA，MONTH_OF_YEAR和DAY_OF_MONTH领域。无论这场或YEAR取决于正在使用的心理模型。查看更多关于这个话题的讨论ChronoLocalDate。
    
    在默认的ISO的日历系统，有两个时代的定义，“公元前”和“CE”。时代的“行政长官”是目前在使用和一年的时代从1运行到最大值。时代的公元前的是以前的时代，与时代背道而驰的一年。
    
    例如，减去一年每次产量如下：
    年预期2 =“CE”年的时代2
    年预期1 =“CE”年的时代1
    年预期0 =“公元前”年的时代1
    年预期- 1 =“公元前”年的时代2
    
    注意ISO-8601标准并不定义的时代。还请注意，ISO的时代不符合知名广告/公元前时代，由于朱利安和阳历系统之间的变化。
    
    非等日历系统应使用最认可的一年的日历系统的用户的时代价值来实现这一领域。由于大多数日历系统只有两个时代，时代的编号方法的一年通常是相同的，由国际标准化组织日历系统所使用的。一年的时代价值通常应该是积极的，但是这是不需要的。
  - YEAR
```
public static final ChronoField YEAR
```
    预期的一年，如2012。
    这代表了一年的概念，按顺序计数和使用负数。预期年不在时代的解释。看到一个例子显示的映射从预期每年的时代YEAR_OF_ERA。
    
    日期的标准心智模型是基于三个概念，一年，一个月和一天。这些Map上YEAR，MONTH_OF_YEAR和DAY_OF_MONTH领域。请注意，没有对时代的参考。一个日期的完整模型需要四个概念：时代、年、月和日。这些Map上ERA，YEAR_OF_ERA，MONTH_OF_YEAR和DAY_OF_MONTH领域。无论这场或YEAR_OF_ERA取决于正在使用的心理模型。查看更多关于这个话题的讨论ChronoLocalDate。
    
    非等时日历系统应实现如下所示。如果日历系统中只有两个时代，在一个固定的日期后，则预期年值必须为后来的时代价值的一年，和以前的时代越来越消极。如果日历系统有两个以上的时代，那么预期年值可以以任何适当的价值定义，虽然定义它是ISO同样可能是最好的选择。
  - ERA
```
public static final ChronoField ERA
```
    时代。
    这代表了时代的概念，这是时间线的最大划分。这场是典型的用YEAR_OF_ERA。
    
    在默认的ISO的日历系统，有两个时代的定义，“公元前”和“CE”。时代的“行政长官”是目前在使用和一年的时代从1运行到最大值。时代的公元前的是以前的时代，与时代背道而驰的一年。看到一个完整的示例YEAR_OF_ERA。
    
    非等时日历系统应该实现这一领域来定义时代。这个时代的价值，是积极1970-01-01（ISO）必须被赋值为1。早期时代必须有顺序较小的值。后来的时代必须有更大的价值观，
  - INSTANT_SECONDS
```
public static final ChronoField INSTANT_SECONDS
```
    瞬间时代秒。
    这是在1970-01-01t00:00z秒的顺序数的概念（ISO）为零。这个字段可以用于NANO_OF_SECOND代表第二部分。
    
    一个Instant代表时间线的瞬时点。在他们自己的，一个瞬间有足够的信息，让当地日期时间获得。只有当与偏移或时区配对时，才能计算本地日期或时间。
    
    此字段被严格定义为在所有日历系统中都具有相同的含义。这是确保互操作日历。
  - OFFSET_SECONDS
```
public static final ChronoField OFFSET_SECONDS
```
    从UTC偏移/格林尼治。
    这是从UTC /格林尼治当地时间秒的偏移量的概念。
    
    一个ZoneOffset代表时间，当地时间与UTC /格林尼治。这通常是一个固定的小时数和分钟数。这相当于在几秒钟内偏移的total amount。例如，在冬季的巴黎有+01:00偏移，这是3600秒。
    
    此字段被严格定义为在所有日历系统中都具有相同的含义。这是确保互操作日历。
- 方法详细信息
  - values
```
public static ChronoField[] values()
```
    返回一个数组包含该枚举类型的常量，它们的顺序声明。这种方法可以用来遍历常数如下：
```
对于（chronofield C：chronofield。values()） 系统，println（C）；
```
    结果
    
    这个数组包含枚举类型的常量，它们的顺序声明
  - valueOf
```
public static ChronoField valueOf(String name)
```
    返回此类型具有指定名称的枚举常量。字符串必须匹配确切地用来声明一个枚举本型常数标识符。（多余空格的字符是不允许的。）
    
    参数
    
    name -定要返回的枚举的名称。
    
    结果
    
    具有指定名称的枚举常量
    
    异常
    
    IllegalArgumentException -如果这个枚举类型，也没有固定的具有指定名称
    
    NullPointerException -如果参数为空
  - getDisplayName
```
public String getDisplayName(Locale locale)
```
    从接口复制的描述： TemporalField
    
    获取所请求的区域设置中的字段的显示名称。
    如果没有区域设置的显示名称，则必须返回一个合适的默认值。
    
    默认的实现必须现场检查不空回toString()。
    
    Specified by:
    
    getDisplayName 接口 TemporalField
    
    参数
    
    locale -现场使用，不为空
    
    结果
    
    用于区域设置或一个合适的默认值的显示名称，而不是空的
  - getBaseUnit
```
public TemporalUnit getBaseUnit()
```
    从接口复制的描述： TemporalField
    
    获取字段的单位，该字段在。
    该字段的单位是在范围内变化的期间。例如，在该领域monthofyear”，单位是“月”。又见TemporalField.getRangeUnit()。
    
    Specified by:
    
    getBaseUnit 接口 TemporalField
    
    结果
    
    定义字段的基本单位的期间单位，而不是空的
  - getRangeUnit
```
public TemporalUnit getRangeUnit()
```
    从接口复制的描述： TemporalField
    
    获取字段所绑定的范围。
    字段的范围是字段在不同的范围内变化的周期。例如，在该领域monthofyear '范围'年'。又见TemporalField.getBaseUnit()。
    
    该范围是永远不会空。例如，“年”字段是“yearofforever的速记。因此，它有一个单位的“年”和一系列的“永远”。
    
    Specified by:
    
    getRangeUnit 接口 TemporalField
    
    结果
    
    定义字段的范围的期间单位，而不是空的
  - range
```
public ValueRange range()
```
    获取字段的有效值的范围。
    所有字段可以表示为一个long整数。此方法返回一个对象，该对象描述该值的有效范围。
    
    此方法返回的日历系统ISO-8601的领域范围。此范围可能是不正确的其他日历系统。使用Chronology.range(ChronoField)访问不同的日历系统正确的范围。
    
    请注意，结果只描述了最小值和最大值的有效值，重要的是不要对它们进行太多的阅读。例如，可能在字段无效的范围内的值。
    
    Specified by:
    
    range 接口 TemporalField
    
    结果
    
    字段的有效值的范围，而不是空值
  - isDateBased
```
public boolean isDateBased()
```
    检查此字段是否代表日期的一个组件。
    从一周天到时代的领域是基于日期的。
    
    Specified by:
    
    isDateBased 接口 TemporalField
    
    结果
    
    如果它是日期的一个组件
  - isTimeBased
```
public boolean isTimeBased()
```
    检查此字段是否表示时间的一个组件。
    纳米二上午下午白天场时间。
    
    Specified by:
    
    isTimeBased 接口 TemporalField
    
    结果
    
    如果它是一个时间的一个组成部分
  - checkValidValue
```
public long checkValidValue(long value)
```
    检查指定的值对该字段是否有效。
    这验证了价值是在外部范围有效的返回值range()。
    
    该方法对该领域的范围在ISO-8601日历系统。此范围可能是不正确的其他日历系统。使用Chronology.range(ChronoField)访问不同的日历系统正确的范围。
    
    参数
    
    value价值-检查
    
    结果
    
    被传递的值
  - checkValidIntValue
```
public int checkValidIntValue(long value)
```
    检查指定的值是有效的，适合在一个 int
    这验证了价值是在外部范围有效的返回值range()。它还检查所有有效值是在一个int界限。
    
    该方法对该领域的范围在ISO-8601日历系统。此范围可能是不正确的其他日历系统。使用Chronology.range(ChronoField)访问不同的日历系统正确的范围。
    。
    
    参数
    
    value价值-检查
    
    结果
    
    被传递的值
  - isSupportedBy
```
public boolean isSupportedBy(TemporalAccessor temporal)
```
    从接口复制的描述： TemporalField
    检查此字段是否被时间对象支持。
    这一决定的时间访问支持这场。如果这个返回假，时间不能被查询此字段。
    
    使用这种方法有两个等效的方法。首先是直接调用这个方法。二是用TemporalAccessor.isSupported(TemporalField)：
```
这两条线是等价的，但第二种方法是建议时间=系统issupportedby（时间）；时间=时间”（研究）；
```
    建议使用第二种方法， isSupported(TemporalField)，因为它是一个更清晰的读码。
    实现应该确定他们是否在ChronoField使用领域提供支持。
    Specified by:
    
    isSupportedBy 接口 TemporalField
    
    参数
    
    temporal -查询时间的对象，不为空
    
    结果
    
    如果日期时间可以查询此字段，则为假如果不是
  - rangeRefinedBy
```
public ValueRange rangeRefinedBy(TemporalAccessor temporal)
```
    从接口复制的描述： TemporalField
    获取此字段的有效值的范围，使用时间对象来细化结果。
    这使用时间对象来查找字段的有效值的范围。这是类似于TemporalField.range()，然而这种方法提炼的结果使用时间。例如，如果该字段是DAY_OF_MONTH的range方法不准确，可能有四个月的长度，28、29、30和31天。使用该方法与日期允许范围是准确的，返回的只有一个这四个选项。
    
    使用这种方法有两个等效的方法。首先是直接调用这个方法。二是用TemporalAccessor.range(TemporalField)：
```
这两条线是等价的，但第二种方法是建议时间=系统rangerefinedby（时间）；时间=时间范围（领域）；
```
    建议使用第二种方法， range(TemporalField)，因为它是一个更清晰的读码。
    实现应该执行任何查询或计算字段可在ChronoField。如果字段不支持UnsupportedTemporalTypeException必须扔。
    Specified by:
    
    rangeRefinedBy 接口 TemporalField
    
    参数
    
    temporal -用于细化结果的时空对象，不为空
    
    结果
    
    此字段的有效值的范围，而不是空值
  - getFrom
```
public long getFrom(TemporalAccessor temporal)
```
    从接口复制的描述： TemporalField
    从指定的时间对象中获取此字段的值。
    此查询此字段的值的时间对象。
    
    使用这种方法有两个等效的方法。首先是直接调用这个方法。二是用TemporalAccessor.getLong(TemporalField)（或TemporalAccessor.get(TemporalField)）：
```
这两条线是等价的，但第二种方法是建议时间=系统从（时间）；时间=时间。getlong（研究）；
```
    建议使用第二种方法， getLong(TemporalField)，因为它是一个更清晰的读码。
    实现应该执行任何查询或计算字段可在ChronoField。如果字段不支持UnsupportedTemporalTypeException必须扔。
    Specified by:
    
    getFrom 接口 TemporalField
    
    参数
    
    temporal -查询时间的对象，不为空
    
    结果
    
    这个字段的值，不是空的
  - adjustInto
```
public <R extends Temporal> R adjustInto(R temporal,
                                         long newValue)
```
    从接口复制的描述： TemporalField
    返回一个指定的时间对象的副本，此字段集的值为。
    这将返回一个新的基于指定的时间对象，这个字段的值改变了。例如，在一个LocalDate，这可以用来设置年、月、日月。返回的对象具有相同的可观察的类型作为指定的对象。
    
    在某些情况下，改变一个字段没有完全定义。例如，如果目标对象是代表1月31日的日期，则更改月至二月将不清楚。在这样的情况下，实施是负责解决结果。通常情况下，它会选择以前的有效日期，这将是二月的最后一个有效的一天，在这个例子中。
    
    使用这种方法有两个等效的方法。首先是直接调用这个方法。二是用Temporal.with(TemporalField, long)：
```
这两条线是等价的，但第二种方法是建议时间=系统adjustinto（时间）；时间=时间，（研究）；
```
    建议使用第二种方法， with(TemporalField)，因为它是一个更清晰的读码。
    实现应该执行任何查询或计算字段可在ChronoField。如果字段不支持UnsupportedTemporalTypeException必须扔。
    
    实现不能更改指定的时间对象。相反，必须返回原始的调整副本。这提供了等效，为不变的和可变的实现安全的行为。
    Specified by:
    
    adjustInto 接口 TemporalField
    
    参数类型
    
    R -时空对象的类型
    
    参数
    
    temporal -调整时间的对象，不为空
    
    newValue -领域新价值
    
    结果
    
    调整后的时间对象，而不是空
  - toString
```
public String toString()
```
    从阶级复制的描述： Enum
    
    返回此枚举常量的名称，包含在声明。这种方法可以被重写，但它通常是不必要的或可取的。一个枚举类型应重写此方法，当一个更“程序员友好”的字符串形式存在。
    
    Specified by:
    
    toString 接口 TemporalField
    
    重写：
    
    toString 方法重写，继承类 Enum<ChronoField>
    
    结果
    
    该枚举的名称常数

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.

Enum ChronoField

Enum Constant Summary

方法摘要

Methods inherited from class java.lang.Enum

Methods inherited from class java.lang.Object

Methods inherited from interface java.time.temporal.TemporalField

Enum Constant Detail

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

DAY_OF_WEEK

ALIGNED_DAY_OF_WEEK_IN_MONTH

ALIGNED_DAY_OF_WEEK_IN_YEAR

DAY_OF_MONTH

DAY_OF_YEAR

EPOCH_DAY

ALIGNED_WEEK_OF_MONTH

ALIGNED_WEEK_OF_YEAR

MONTH_OF_YEAR

PROLEPTIC_MONTH

YEAR_OF_ERA

YEAR

ERA

INSTANT_SECONDS

OFFSET_SECONDS

方法详细信息

values

valueOf

getDisplayName

getBaseUnit

getRangeUnit

range

isDateBased

isTimeBased

checkValidValue

checkValidIntValue

isSupportedBy

rangeRefinedBy

getFrom

adjustInto

toString