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来扩展标准的字段集。

这些字段旨在适用于多个日历系统。例如，大多数非ISO日历系统将日期定义为年，月和日，只是略有不同的规则。每个领域的文档解释了它的运作方式。

实现要求：

这是一个最终的，不可变的和线程安全的枚举。

从以下版本开始：

1.8

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（ISO）的Java时代的时代。
`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` 一月份，如三月。
`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到999,999,999之间的纳秒。该字段对于所有日历系统具有相同的含义。
    
    该字段用于表示二分之一处理任何二分之一的纳秒。的实现TemporalAccessor应该为这一领域提供一个值，如果他们可以返回一个值SECOND_OF_MINUTE ， SECOND_OF_DAY或INSTANT_SECONDS灌装精度不明零。
    
    当该字段用于设置值时，应设置与对象存储的精度相同的精度，使用整除除去多余的精度。例如，如果TemporalAccessor存储时间到毫秒的精度，那么在更换毫秒之前，纳秒必须除以1,000,000。
    
    解析此字段时，其行为等同于以下内容：该值在严格和智能模式下验证，但不在宽大模式下验证。该字段与MILLI_OF_SECOND和MICRO_OF_SECOND 。
  - NANO_OF_DAY
```
public static final ChronoField NANO_OF_DAY
```
    纳纳天。
    这是在一天内的纳秒，从0到（24 * 60 * 60 * 1,000,000,000） - 1.这个字段对于所有日历系统都具有相同的含义。
    
    该字段用于表示纳秒的处理任何分数的第二。 TemporalAccessor的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到999,999之间的微秒。该字段对于所有日历系统具有相同的含义。
    
    该字段用于表示第二次处理任何分数的微秒。的实现TemporalAccessor应该为这一领域提供一个值，如果他们可以返回一个值SECOND_OF_MINUTE ， SECOND_OF_DAY或INSTANT_SECONDS灌装精度不明零。
    
    当此字段用于设置一个值，也应做同样的方式为设定NANO_OF_SECOND并乘以1000的值。
    
    解析此字段时，其行为等同于以下内容：该值在严格和智能模式下验证，但不在宽大模式下验证。该字段与MILLI_OF_SECOND结合MILLI_OF_SECOND以生成NANO_OF_SECOND 。
  - MICRO_OF_DAY
```
public static final ChronoField MICRO_OF_DAY
```
    微观的一天。
    这是一天内的微秒，从0到（24 * 60 * 60 * 1,000,000） - 1.这个字段对于所有的日历系统都是一样的。
    
    该字段用于表示微时间处理任何第二个分数。 TemporalAccessor的TemporalAccessor应该为该字段提供一个值，如果它们可以返回一个填充未知精度为零的值，那么这个值为SECOND_OF_DAY 。
    
    当此字段用于设置一个值，也应做同样的方式为设定NANO_OF_DAY并乘以1000的值。
    
    解析此字段时，其行为等同于以下内容：该值在严格和智能模式下验证，但不在宽大模式下验证。该值将被分割，以形成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灌装精度不明零。
    
    当此字段用于设置值时，它的行为方式与设置NANO_OF_SECOND相同，值乘以1,000,000。
    
    解析此字段时，其行为等同于以下内容：该值在严格和智能模式下验证，但不在宽大模式下验证。该领域与MICRO_OF_SECOND结合生产NANO_OF_SECOND 。
  - MILLI_OF_DAY
```
public static final ChronoField MILLI_OF_DAY
```
    毫无疑问
    这是一天内的毫秒数，从0到（24 * 60 * 60 * 1,000） - 1。这个字段对于所有的日历系统都是一样的。
    
    该字段用于表示每天处理任何二分之一的数据。的实现TemporalAccessor应该为这一领域提供一个值，如果他们可以返回一个值SECOND_OF_DAY填充未知精密零。
    
    当此字段用于设置值时，它的行为方式与设置NANO_OF_DAY相同，值乘以1,000,000。
    
    解析此字段时，其行为等同于以下内容：该值在严格和智能模式下验证，但不在宽大模式下验证。该值将被分割，以形成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
```
    上午的小时。
    这将计算AM / PM中的时间，从0到11.这是在标准的12小时数字时钟上观察到的时间。该字段对于所有日历系统具有相同的含义。
    
    解析此字段时，其行为等同于以下内容：该值在严格和智能模式下从0到11进行验证。在宽松模式下，该值不被验证。通过将{AMPM_OF_DAY}值乘以12，结合AMPM_OF_DAY形成HOUR_OF_DAY 。
  - CLOCK_HOUR_OF_AMPM
```
public static final ChronoField CLOCK_HOUR_OF_AMPM
```
    上午的时钟小时。
    这将在AM / PM中的时间从1到12计数。这是在标准的12小时模拟挂钟上观察到的时间。该字段对于所有日历系统具有相同的含义。
    
    解析此字段时，其行为等同于以下内容：该值在严格模式下从1到12，在智能模式下从0到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
```
    时钟的一天。
    这将计时AM / PM中的时间从1到24.这是在24小时模拟挂钟上观察到的时间。该字段对于所有日历系统具有相同的含义。
    
    解析此字段时，其行为等同于以下内容：该值在严格模式下从1到24，在智能模式下从0到24。在宽松模式下，该值不被验证。该字段将转换为具有相同值的HOUR_OF_DAY ，除非值为24，在这种情况下，该字段将转换为0。
  - AMPM_OF_DAY
```
public static final ChronoField AMPM_OF_DAY
```
    今天下午。
    这将在一天内的AM / PM计数，从0（AM）到1（PM）。该字段对于所有日历系统具有相同的含义。
    
    当解析此字段时，其行为等同于以下内容：该值在严格和智能模式下从0到1被验证。在宽松模式下，该值不被验证。通过将{AMPM_OF_DAY}值乘以12，结合HOUR_OF_AMPM形成HOUR_OF_DAY 。
  - DAY_OF_WEEK
```
public static final ChronoField DAY_OF_WEEK
```
    星期二，例如星期二。
    这代表了星期几的标准概念。在默认的ISO日历系统中，它具有从星期一（1）到星期日（7）的值。 DayOfWeek类可以用来解释结果。
    
    大多数非ISO日历系统还定义了符合ISO的七天周。这些日历系统也必须使用相同的编号系统，从星期一（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一起使用。
    
    例如，在一个七天的日历系统中，第一个对齐的年份从一年的第一天开始，第二个对齐的一周从第8天开始，依此类推。在每个这些对齐的周内，天数从1到7，并作为该字段的值返回。因此，1 - 7年的日期将在1到7之间保持一致的日期值。8至14的每一天将重复此操作，每周的值从1到7。
    
    没有七天的日历系统通常以相同的方式实现此字段，但使用替代周长度。
  - DAY_OF_MONTH
```
public static final ChronoField DAY_OF_MONTH
```
    月日。
    这代表了一个月内的一天的概念。在默认的ISO日历系统中，它在大多数月份中的值为1到31。 4月，6月，9月，11月有1到30天，而2月有1到28天，闰年29天。
    
    非ISO日历系统应使用日历系统的用户使用最确定的日期值实现此字段。通常，这是从1到月的长度的天数。
  - DAY_OF_YEAR
```
public static final ChronoField DAY_OF_YEAR
```
    一年的一天。
    这代表了一年中的一天的概念。在默认ISO日历系统中，标准年份的值为1到365，闰年的值为1到366。
    
    非ISO日历系统应使用日历系统用户的最确定日期值实现此字段。通常，这是从1到年的长度的天数。
    
    请注意，非ISO日历系统可能具有年号编号系统，在不同点更改月份编号中的自然重置。一个例子是日历日历系统，其中将时间的变化重置为1，可以在任何日期发生。年龄和年份重置也导致年的日期重置为1，但不是月的年份或月份。
  - EPOCH_DAY
```
public static final ChronoField EPOCH_DAY
```
    基于1970-01-01（ISO）的Java时代的时代。
    该字段是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一起使用。
    
    例如，在一个七天的日历系统中，第一个对齐的年份从一年的第一天开始，第二个对齐的一周从第8天开始，依此类推。因此，日期值1到7在第1周对齐，而日期值8至14在第2周排列，依此类推。
    
    没有七天的日历系统通常以相同的方式实现此字段，但使用替代周长度。
  - MONTH_OF_YEAR
```
public static final ChronoField MONTH_OF_YEAR
```
    一月份，如三月。
    这代表了一年中的一个月的概念。在默认的ISO日历系统中，它具有从1月（1）到12月（12）的值。
    
    非ISO日历系统应使用日历系统用户最为认可的月份值来实现此字段。通常，这是从1开始的月数。
  - PROLEPTIC_MONTH
```
public static final ChronoField PROLEPTIC_MONTH
```
    以月份为基础，从0年起连续数月。
    这个字段是在初步年份零的第一个月为零的月份的连续计数。后来几个月的价值越来越大。前几个月的价值越来越小。几个月的顺序没有差距或断裂。请注意，这使用本地时间线，忽略偏移和时区。
    
    在默认的ISO日历系统中，2012年6月将具有值(2012 * 12 + 6 - 1) 。该领域主要用于内部使用。
    
    非ISO日历系统必须按照上述定义实现此字段。这仅仅是从开始的初步年份0开始就已经过去的零月份的一个简单的零计数。具有完整的幼年年定义的所有日历系统将有一个零年。如果日历系统具有排除零年的最小年份，那么必须外推一个，以便定义该方法。
  - YEAR_OF_ERA
```
public static final ChronoField YEAR_OF_ERA
```
    时代的一年。
    这代表了时代的一年的概念。该字段通常与ERA一起使用。
    
    日期的标准心理模型基于三个概念 - 年，月和日。这些映射到YEAR ， MONTH_OF_YEAR和DAY_OF_MONTH领域。请注意，没有参考时代。日期的完整模式需要四个概念 - 时代，年，月和日。这些映射到ERA ， YEAR_OF_ERA ， MONTH_OF_YEAR和DAY_OF_MONTH领域。是否使用此字段或YEAR取决于正在使用的心理模型。有关此主题的更多讨论，请参阅ChronoLocalDate 。
    
    在默认的ISO日历系统中，有两个定义为“BCE”和“CE”的时间。 “CE”时代是目前正在使用的时代，从年龄的1岁到最大值。时代“公元前”是前一个时代，而一年的时代倒退了。
    
    例如，每次减去一年产生以下结果：
    - 年龄2 ='CE'年龄2
    - 年龄1 ='CE'年龄1
    - 年龄0 ='BCE'年龄1
    - 年龄 - 1岁='BCE'年龄2
    
    请注意，ISO-8601标准没有实际定义时间。还要注意，由于Julian和Gregorian日历系统之间的变化，ISO时代与公知的AD / BC时代不一致。
    
    非ISO日历系统应使用日历系统用户最为认可的年龄值实现此领域。由于大多数日历系统只有两个时代，因此年龄编号方法通常与ISO日历系统使用的方法相同。年龄的价值通常应该是积极的，但这不是必需的。
  - YEAR
```
public static final ChronoField YEAR
```
    这样的一年，如2012年。
    这代表了一年的概念，顺序排列并使用负数。这个年龄不是从时代来解释的。参见YEAR_OF_ERA ，显示了从幼年到年龄的映射。
    
    日期的标准心理模型基于三个概念 - 年，月和日。这些映射到YEAR ， MONTH_OF_YEAR和DAY_OF_MONTH领域。请注意，没有参考时代。日期的完整模式需要四个概念 - 时代，年，月和日。这些映射到ERA ， YEAR_OF_ERA ， MONTH_OF_YEAR和DAY_OF_MONTH领域。是否使用此字段或YEAR_OF_ERA取决于正在使用的心理模型。有关此主题的更多讨论，请参阅ChronoLocalDate 。
    
    非ISO日历系统应实现此字段如下。如果日历系统在固定日期之前和之后只有两个时期，则幼年时期的价值必须与后期时代的年龄值相同，而对于较早的时代而言，日渐增长的负值越来越大。如果日历系统有两个以上的时间，那么可以用任何适当的值来定义幼龄年份值，尽管将其定义为与ISO相同可能是最佳选择。
  - ERA
```
public static final ChronoField ERA
```
    时代。
    这代表了时代的概念，这是时代最大的一个部门。该字段通常与YEAR_OF_ERA一起使用。
    
    在默认的ISO日历系统中，有两个定义为“BCE”和“CE”的时间。 “CE”时代是目前正在使用的时代，从年龄的1岁到最大值。时代“公元前”是前一个时代，而一年的时代倒退了。有关完整的示例，请参阅YEAR_OF_ERA 。
    
    非ISO日历系统应实现此字段来定义时间。在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 /格林威治当地时间的偏移量的概念。
    
    A ZoneOffset代表当地时间与UTC /格林威治时间不同的时间段。这通常是固定的几小时和几分钟。相当于total amount的偏移量，以秒为单位。例如，在冬季，巴黎的偏移量为+01:00 ，即3600秒。
    
    该字段被严格定义为在所有日历系统中具有相同的含义。这是必要的，以确保日历之间的互操作。
- 方法详细信息
  - values
```
public static ChronoField[] values()
```
    按照它们声明的顺序返回一个包含此枚举类型常量的数组。该方法可用于遍历常量如下：
```
  for (ChronoField c : ChronoField.values())
    System.out.println(c); 
```
    结果
    
    一个包含这个枚举类型的常量的数组，按照它们被声明的顺序
  - valueOf
```
public static ChronoField valueOf(String name)
```
    以指定的名称返回此类型的枚举常量。字符串必须完全匹配用于声明此类型的枚举常量的标识符。（不允许使用外来空白字符。）
    
    参数
    
    name - 要返回的枚举常量的名称。
    
    结果
    
    具有指定名称的枚举常数
    
    异常
    
    IllegalArgumentException - 如果此枚举类型没有指定名称的常量
    
    NullPointerException - 如果参数为空
  - getDisplayName
```
public String getDisplayName(Locale locale)
```
    说明从界面： TemporalField复制
    
    获取所请求语言环境中字段的显示名称。
    如果区域设置没有显示名称，则必须返回合适的默认值。
    
    默认实现必须检查locale不为null并返回toString() 。
    
    Specified by:
    
    getDisplayName在接口 TemporalField
    
    参数
    
    locale - 要使用的区域设置，不为空
    
    结果
    
    区域设置的显示名称或合适的默认值，不为空
  - getBaseUnit
```
public TemporalUnit getBaseUnit()
```
    描述从接口： TemporalField复制
    
    获取测量场的单位。
    字段的单位是在该范围内变化的周期。例如，在“MonthOfYear”字段中，单位为“Months”。参见TemporalField.getRangeUnit() 。
    
    Specified by:
    
    getBaseUnit在接口 TemporalField
    
    结果
    
    定义字段的基本单位的周期单位不为空
  - getRangeUnit
```
public TemporalUnit getRangeUnit()
```
    说明从界面： TemporalField复制
    
    获取字段绑定的范围。
    字段的范围是字段在内部变化的周期。例如，在“MonthOfYear”字段中，范围是“年”。参见TemporalField.getBaseUnit() 。
    
    范围从不为空。例如，'Year'字段是'YearOfForever'的缩写。因此，它具有“年”和“永远”的单位。
    
    Specified by:
    
    getRangeUnit在接口 TemporalField
    
    结果
    
    定义字段范围的周期单位，不为空
  - range
```
public ValueRange range()
```
    获取字段的有效值的范围。
    所有字段可以表示为long整数。此方法返回描述该值的有效范围的对象。
    
    此方法返回ISO-8601日历系统中的字段范围。其他日历系统的范围可能不正确。使用Chronology.range(ChronoField)访问不同日历系统的正确范围。
    
    请注意，结果仅描述最小和最大有效值，重要的是不要太多读取它们。例如，可以在该范围内的值对该字段无效。
    
    Specified by:
    
    range在界面 TemporalField
    
    结果
    
    字段的有效值的范围不为null
  - isDateBased
```
public boolean isDateBased()
```
    检查此字段是否表示日期的组件。
    从星期几到时代的领域是基于日期的。
    
    Specified by:
    
    isDateBased在接口 TemporalField
    
    结果
    
    如果它是日期的组成部分，则为true
  - 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复制
    检查时间对象是否支持该字段。
    这决定了临时访问者是否支持该字段。如果这返回false，则不能查询该字段的时间。
    
    使用这种方法有两种等效的方法。第一个是直接调用这个方法。二是使用TemporalAccessor.isSupported(TemporalField) ：
```
  // these two lines are equivalent, but the second approach is recommended
   temporal = thisField.isSupportedBy(temporal);
   temporal = temporal.isSupported(thisField); 
```
    建议使用第二种方法， isSupported(TemporalField) ，因为在代码中阅读更清楚。
    实现应该确定他们使用可用的字段是否支持ChronoField 。
    Specified by:
    
    isSupportedBy在接口 TemporalField
    
    参数
    
    temporal - 要查询的时间对象，不为空
    
    结果
    
    如果可以查询此字段的日期时间，则为true，否则为false
  - rangeRefinedBy
```
public ValueRange rangeRefinedBy(TemporalAccessor temporal)
```
    描述从接口： TemporalField复制
    使用时间对象获取此字段的有效值的范围以优化结果。
    这使用时间对象来查找该字段的有效值的范围。这类似于TemporalField.range() ，但是这种方法使用时间来优化结果。例如，如果字段为DAY_OF_MONTH那么range方法不准确，因为有四个可能的月份长度，28,29,30和31天。使用此方法与日期允许范围准确，只返回这四个选项之一。
    
    使用这种方法有两种等效的方法。第一个是直接调用这个方法。二是使用TemporalAccessor.range(TemporalField) ：
```
  // these two lines are equivalent, but the second approach is recommended
   temporal = thisField.rangeRefinedBy(temporal);
   temporal = temporal.range(thisField); 
```
    建议使用第二种方法， range(TemporalField) ，因为在代码中阅读更清楚。
    实施应使用ChronoField中可用的字段执行任何查询或计算。如果不支持该字段，则必须抛出一个UnsupportedTemporalTypeException 。
    Specified by:
    
    rangeRefinedBy在接口 TemporalField
    
    参数
    
    temporal - 用于细化结果的时间对象，不为null
    
    结果
    
    该字段的有效值的范围不为null
  - getFrom
```
public long getFrom(TemporalAccessor temporal)
```
    描述从界面： TemporalField复制
    从指定的时间对象获取此字段的值。
    这将查询该时间对象的该字段的值。
    
    使用这种方法有两种等效的方法。第一个是直接调用这个方法。二是使用TemporalAccessor.getLong(TemporalField) （或TemporalAccessor.get(TemporalField) ）：
```
  // these two lines are equivalent, but the second approach is recommended
   temporal = thisField.getFrom(temporal);
   temporal = temporal.getLong(thisField); 
```
    建议使用第二种方法， getLong(TemporalField) ，因为在代码中阅读更清楚。
    实施应使用ChronoField中可用的字段执行任何查询或计算。如果不支持该字段，则必须抛出一个UnsupportedTemporalTypeException 。
    Specified by:
    
    getFrom在界面 TemporalField
    
    参数
    
    temporal - 要查询的时间对象，不为空
    
    结果
    
    该字段的值不为null
  - adjustInto
```
public <R extends Temporal> R adjustInto(R temporal,
                                         long newValue)
```
    说明从界面： TemporalField复制
    返回指定时间对象的副本，并设置该字段的值。
    这将返回一个新的时间对象，该对象基于指定的时间对象，该字段的值已更改。例如，在LocalDate ，这可以用于设置年，月或月的日期。返回的对象具有与指定对象相同的可观察类型。
    
    在某些情况下，更改字段尚未完全定义。例如，如果目标对象是代表1月31日的日期，则将月份更改为2月份将不清楚。在这种情况下，实施负责解决结果。通常，它将选择先前的有效日期，这将是本例中最后一个有效的二月份。
    
    使用这种方法有两种等效的方法。第一个是直接调用这个方法。二是使用Temporal.with(TemporalField, long) ：
```
  // these two lines are equivalent, but the second approach is recommended
   temporal = thisField.adjustInto(temporal);
   temporal = temporal.with(thisField); 
```
    建议使用第二种方法， with(TemporalField) ，因为在代码中阅读更清楚。
    实施应使用ChronoField中可用的字段执行任何查询或计算。如果不支持该字段，则必须抛出一个UnsupportedTemporalTypeException 。
    
    实现不能改变指定的时间对象。相反，必须退还原件的调整副本。这为不可变和可变的实现提供了相当的安全行为。
    Specified by:
    
    adjustInto在接口 TemporalField
    
    参数类型
    
    R - 时间对象的类型
    
    参数
    
    temporal - 要调整的时间对象，不为null
    
    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