ChronoLocalDate (Java Platform SE 8 )

All Superinterfaces:

Comparable < ChronoLocalDate >， Temporal， TemporalAccessor， TemporalAdjuster

所有已知实现类：

HijrahDate， JapaneseDate， LocalDate， MinguoDate， ThaiBuddhistDate
```
public interface ChronoLocalDate
extends Temporal, TemporalAdjuster, Comparable<ChronoLocalDate>
```
一个没有时间的天或时间区的日期，在一个任意的年代，用于先进的全球化用例。
大多数应用程序都应声明方法签名，字段和变量LocalDate，不是这个界面。

一个ChronoLocalDate是抽象表示的日期，Chronology chronology，或日历系统，是可插拔。日期字段中所表达的TemporalField术语定义，其中最常见的实现定义在ChronoField。年表定义日历系统的运作和标准领域的意义。

何时使用此接口
API的设计鼓励 LocalDate而不是使用这个接口，即使在应用程序需要处理多个日历系统的情况下。这一理论的基本原理是在下面的文档中进行。
主要使用这个接口应该是泛型类型参数<D>完全定义为一个特定的时间。在这种情况下，该时间的假设是已知的在开发时间，并在代码中指定。

当时间顺序被定义在泛型类型参数为？或其他未知的开发时间，下面的讨论适用于。

为了强调这一点，声明一个方法签名字段或变量为这个接口类型可以初步全球化应用程序似乎是明智的办法，但它通常是错误的做法。因此，它应该被认为是一种应用广泛的建筑决定选择使用这个接口作为反对LocalDate。

建筑问题要考虑
这些都是必须在使用该接口在应用程序的角度考虑。
1）使用这个接口的应用，而不是只使用LocalDate，面临着较高概率的错误。这是因为在开发时使用的日历系统是不知道的。错误的一个关键原因是，开发人员将假设从他们的日常知识的的的的的的日历系统的代码，是打算处理任何任意的日历系统。下面的部分概述了这些假设可能会导致问题的主要机制，减少这种增加的错误的风险是一个强大的代码审查过程。这也应该被认为是一个额外的成本在维护的代码的生命期。

2）这个接口没有强制不变性的实现。虽然实现注释表明所有的实现都必须是不可改变的，代码或类型系统中没有任何东西可以强制执行。任何方法宣布接受ChronoLocalDate因此可以通过无知或恶意的书面的实施。

3）使用此接口的应用程序必须考虑时代的影响。LocalDate屏蔽用户时代的概念，以确保getYear()预期年收益。这一决定使得开发者可以认为LocalDate实例由三个领域的一年，一年一个月。相比之下，这个界面的用户必须认为日期是由四个领域-时代，一年的时代，一个月的一年，一天一天。额外的时代领域是经常被遗忘的，但它是最重要的日期在一个任意的日历系统。例如，在日本历法系统中，这个时代代表了一个皇帝的统治。每当一个统治结束，另一个开始，这个时代的一年被重置为一个。

4）只同意国际标准通过日期两系统之间是ISO-8601标准要求的ISO的日历系统。在整个应用程序中使用这个接口，将不可避免地导致在网络或组件边界上传递日期的要求，需要一个特定于应用程序的协议或格式。

5）长期坚持，如数据库，将几乎总是只接受日期在ISO-8601日历系统（或相关的Julian Gregorian）。通过在其他日历系统中的日期增加了与持久性交互的并发症。

6）大多数时间，通过ChronoLocalDate整个应用程序是不必要的，因为在最后一节讨论。

在多日历系统代码中导致错误的错误假设
如上所述，有许多要考虑的问题时，尝试使用在任意的日历系统操作日期。这些都是一些关键问题。
查询一个月的一天的代码，并假定该值将永远不会超过31是无效的。一些日历系统在几个月内有超过31天的时间。

将12个月添加到日期的代码，并假定一年已添加的代码无效。一些日历系统有一个不同的月数，如13的科普特人和埃塞俄比亚。

一个月增加一个日期的代码，并假定一个月的一年值将增加一个或包装到明年是无效的。有些日历系统在一年中有几个月的时间，如希伯来。

添加一个月的代码，然后添加了一个月的第二个月，并假定每月的一天将保持接近其原始值是无效的。一些日历系统在最长的一个月的长度和最短的月份的长度之间有很大的区别。例如，科普特和埃塞俄比亚有12个月的30天和5天1个月。

添加七天，并假定一个星期已被添加的代码是无效的。一些日历系统有几个星期的时间超过七天，如法国革命。

代码假定因为date1年大于一年后date2然后date1 date2无效。这对所有的日历系统指时代今年是无效的，尤其是不真实的日本日历系统，今年启动的时代的每一个新的皇帝。

将一年一个月一个月的代码作为一年的开始的代码无效。并非所有的日历系统都在一个月的时候开始。

在一般情况下，操纵一个日期，甚至查询一个日期，在开发时间未知的日历系统时，会向错误敞开。这就是为什么它是必不可少的代码使用这个接口进行额外的代码审查。这也是为什么一个建筑的决定，以避免这种接口类型通常是正确的一个。

使用localdate相反
使用这种接口在整个应用程序中主要的选择如下。
- 声明所有的方法签名指从LocalDate日期。
- 无论是存储在用户配置文件中的时间顺序（日历系统）或查找从用户区域的时间顺序
- 将ISO LocalDate和从用户首选的日历系统，打印和解析过程
这种方法对待全球化的日历系统问题作为一个定位问题，限制了它的用户界面层。这种方法是在保持与其他定位问题在java平台。
如上所述，执行计算日期的日历系统的规则是可插拔的需要技巧和不推荐。幸运的是，需要执行计算的日期在一个任意的日历系统是非常罕见的。例如，一个图书馆的图书出租计划的业务规则是不可能的，将允许租金为一个月，在这个月的意义是依赖于用户的首选日历系统。

在一个任意的日历系统中的一个日期计算的一个关键用例是通过一个月的日历来显示和用户交互的。再次，这是一个用户界面问题，并且仅在用户界面层的一些方法中使用这个接口是合理的。

在系统的任何其他部分，在一个日历系统中的其他日期必须被操纵的系统中，使用的情况下，通常会指定日历系统使用。例如，一个应用程序可能需要计算下一个伊斯兰或希伯来节日，这可能需要操纵日期。这种用例可以处理如下：
- 从ISO LocalDate传递给方法的开始
- 将日期转换为备用日历系统，这对于这个用例是已知的，而不是任意的
- 执行计算
- 转换回LocalDate
开发者写的底层框架或库也应该避免这种接口。相反，两个通用的访问接口之一应该被使用。如果需要使用 TemporalAccessor只读访问，或使用 Temporal如果读写访问是必需的。
实现要求：

此接口必须小心地执行，以确保其他类正确操作。所有的实现可以被实例化必须是最终的，不变的，线程安全的。子类应该是可串行化的可能。
额外的日历系统可能被添加到系统中。更多细节见Chronology。

从以下版本开始：

一点八

方法摘要

所有方法静态方法接口方法抽象方法 Default Methods
Modifier and Type	Method and Description
`default Temporal`	`adjustInto(Temporal temporal)` 调整指定的时间对象，以具有此对象的相同日期。
`default ChronoLocalDateTime<?>`	`atTime(LocalTime localTime)` 结合这个日期与时间创建一个 `ChronoLocalDateTime`。
`default int`	`compareTo(ChronoLocalDate other)` 将此日期与另一个日期进行比较，包括年代。
`boolean`	`equals(Object obj)` 检查这个日期是否等于另一个日期，包括年代。
`default String`	`format(DateTimeFormatter formatter)` 使用指定的格式的日期格式。
`static ChronoLocalDate`	`from(TemporalAccessor temporal)` 获得 `ChronoLocalDate`实例从一个时空对象。
`Chronology`	`getChronology()` 获取此日期的日期。
`default Era`	`getEra()` 获取时代，如年代所定义的。
`int`	`hashCode()` 此日期的哈希代码。
`default boolean`	`isAfter(ChronoLocalDate other)` 检查此日期是否在指定日期后忽略了时间顺序。
`default boolean`	`isBefore(ChronoLocalDate other)` 检查此日期是否在指定日期之前忽略了时间顺序。
`default boolean`	`isEqual(ChronoLocalDate other)` 检查此日期是否等于指定日期忽略了时间顺序。
`default boolean`	`isLeapYear()` 检查一年是否是一个跨越，如日历系统所定义的。
`default boolean`	`isSupported(TemporalField field)` 检查指定字段是否被支持。
`default boolean`	`isSupported(TemporalUnit unit)` 检查指定的单位是否被支持。
`int`	`lengthOfMonth()` 返回由日历系统定义的这个日期所表示的月份的长度。
`default int`	`lengthOfYear()` 返回由该日期所表示的年份的长度，如日历系统所定义的一年。
`default ChronoLocalDate`	`minus(long amountToSubtract, TemporalUnit unit)` 返回与指定期间减去的相同类型的对象。
`default ChronoLocalDate`	`minus(TemporalAmount amount)` 返回一个与此对象相同的类型的对象，该对象的金额减去。
`default ChronoLocalDate`	`plus(long amountToAdd, TemporalUnit unit)` 返回与此对象相同的类型的对象，添加指定的周期。
`default ChronoLocalDate`	`plus(TemporalAmount amount)` 返回与此对象添加的相同类型的对象。
`default <R> R`	`query(TemporalQuery<R> query)` 使用指定的查询查询此日期。
`static Comparator<ChronoLocalDate>`	`timeLineOrder()` 获取一个比较器，比较 `ChronoLocalDate`时间线的顺序忽略年表。
`default long`	`toEpochDay()` 将此日期转换为新纪元日。
`String`	`toString()` 输出该日期作为 `String`。
`ChronoPeriod`	`until(ChronoLocalDate endDateExclusive)` 计算这个日期和日期之间的时间作为一个 `ChronoPeriod`。
`long`	`until(Temporal endExclusive, TemporalUnit unit)` 计算时间的量，直到指定单元的另一个日期为止。
`default ChronoLocalDate`	`with(TemporalAdjuster adjuster)` 返回与此对象调整的相同类型的调整对象。
`default ChronoLocalDate`	`with(TemporalField field, long newValue)` 返回与指定字段更改的相同类型的对象。

Methods inherited from interface java.time.temporal.TemporalAccessor
get, getLong, range

- 方法详细信息
  - timeLineOrder
```
static Comparator<ChronoLocalDate> timeLineOrder()
```
    获取一个比较器，比较 ChronoLocalDate时间线的顺序忽略年表。
    该比较器与compareTo(java.time.chrono.ChronoLocalDate)在比较，只是比较底层的日期而不是年表。这允许在不同的日历系统中的日期进行比较的基础上的日期在当地时间线的位置。潜在的比较相当于比较时代的一天。
    
    结果
    
    一个比较时间线顺序忽略时间顺序的比较器
    
    另请参见：
    
    isAfter(java.time.chrono.ChronoLocalDate)， isBefore(java.time.chrono.ChronoLocalDate)， isEqual(java.time.chrono.ChronoLocalDate)
  - from
```
static ChronoLocalDate from(TemporalAccessor temporal)
```
    获得 ChronoLocalDate实例从一个时空对象。
    这将根据指定的时间来获得一个本地日期。一个TemporalAccessor表示日期和时间信息，任意设置，本厂将以ChronoLocalDate实例。
    
    转换提取物，并结合了年代和时间对象的日期。行为相当于使用Chronology.date(TemporalAccessor)与提取的年表。实现允许执行优化，如访问这些字段，这些字段相当于相关对象。
    
    这种方法相匹配的功能接口TemporalQuery可以通过方法引用查询的签名，ChronoLocalDate::from。
    
    参数
    
    temporal -转换时间的对象，不为空
    
    结果
    
    日期，而不是空
    
    异常
    
    DateTimeException如果无法转换为 ChronoLocalDate
    
    另请参见：
    
    Chronology.date(TemporalAccessor)
  - getChronology
```
Chronology getChronology()
```
    获取此日期的日期。
    的Chronology代表使用日历系统。在ChronoField时代和其他领域的时间定义。
    
    结果
    
    的年代，不是空的
  - getEra
```
default Era getEra()
```
    获取时代，如年代所定义的。
    时代是，从概念上说，最大的划分的时间线。大多数日历系统有一个单一的时代划分的时间线分为两个时代。然而，有些人有多个时代，如一个为每个领导人的统治。确切的意思是由Chronology确定。
    
    所有正确的实现Era类都是单身，因此有效的代码写date.getEra() == SomeChrono.ERA_NAME)。
    
    此默认实现使用Chronology.eraOf(int)。
    
    结果
    
    在这个日期适用的特定年代的时代常数，而不是空的
  - isLeapYear
```
default boolean isLeapYear()
```
    检查一年是否是一个跨越，如日历系统所定义的。
    一个跨越是一年比一个更长的长度比正常。确切的意义是由年代确定的约束，即跨越式的一年必须意味着一年的长度比一个非跨越年。
    
    此默认实现使用Chronology.isLeapYear(long)。
    
    结果
    
    如果这个日期是在一个跳跃的一年，否则错误
  - lengthOfMonth
```
int lengthOfMonth()
```
    返回由日历系统定义的这个日期所表示的月份的长度。
    这将返回一个月的长度。
    
    结果
    
    天月的长度
  - lengthOfYear
```
default int lengthOfYear()
```
    返回由该日期所表示的年份的长度，如日历系统所定义的一年。
    这将返回在几天内的长度。
    
    默认的实现使用isLeapYear()返回365或366。
    
    结果
    
    在天的长度
  - isSupported
```
default boolean isSupported(TemporalField field)
```
    检查指定字段是否被支持。
    此检查如果指定的字段可以在这个日期查询。如果为false，则调用range，get和with(TemporalField, long)方法将抛出一个异常。
    
    支持的字段集由年表的定义，通常包括所有ChronoField日期字段。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.isSupportedBy(TemporalAccessor)得到此方法的结果。是否支持字段由字段确定。
    
    Specified by:
    
    isSupported 接口 TemporalAccessor
    
    参数
    
    field -现场检查null返回false
    
    结果
    
    如果字段可以被查询，则为假
  - isSupported
```
default boolean isSupported(TemporalUnit unit)
```
    检查指定的单位是否被支持。
    此检查如果指定的单位可以添加到或从这个日期减去。如果为false，则调用plus(long, TemporalUnit)和minus方法将抛出一个异常。
    
    支持单位集由年表的定义和一般包括除FOREVER所有ChronoUnit日期单位。
    
    如果单位不ChronoUnit，然后通过调用作为参数传递this TemporalUnit.isSupportedBy(Temporal)得到此方法的结果。是否支持单位是由单位确定的。
    
    Specified by:
    
    isSupported 接口 Temporal
    
    参数
    
    unit -检查单元，空返回false
    
    结果
    
    如果单位可以增加/减去，如果没有的话
  - with
```
default ChronoLocalDate with(TemporalAdjuster adjuster)
```
    返回与此对象调整的相同类型的调整对象。
    根据指定的调节器的规则来调整这个日期时间。一个简单的调节器可以简单地设置一个字段，例如年字段。一个更复杂的调节器可能会把日期定在月的最后一天。选择常见的调整提供了TemporalAdjuster。这些包括找到“一个月的最后一天”和“下星期三”。该调节器是负责处理特殊情况下，如不同长度的月和跳跃年。
    
    一些示例代码，说明如何以及为什么使用这种方法：
```
日期=日期（月，七月）；//最关键的类实现temporaladjuster日期为日期，（lastdayofmonth()）；//静态导入调节器日期为日期，（下（星期三））；//静态导入调节器和DayOfWeek
```
    Specified by:
    
    with 接口 Temporal
    
    参数
    
    adjuster -调节器使用，不为空
    
    结果
    
    同一类型的对象，所指定的调整，而不是空
    
    异常
    
    DateTimeException如果无法适应
    
    ArithmeticException如果数值溢出时
  - with
```
default ChronoLocalDate with(TemporalField field,
                             long newValue)
```
    返回与指定字段更改的相同类型的对象。
    这将返回一个新的对象，在此基础上，以指定字段的值更改。例如，在一个LocalDate，这可以用来设置年、月、日月。返回的对象将有相同的可观察的类型作为此对象。
    
    在某些情况下，改变一个字段没有完全定义。例如，如果目标对象是代表1月31日的日期，则更改月至二月将不清楚。在这样的情况下，该字段负责解决结果。通常情况下，它会选择以前的有效日期，这将是二月的最后一个有效的一天，在这个例子中。
    
    Specified by:
    
    with 接口 Temporal
    
    参数
    
    field -现场设置的结果，不为空
    
    newValue -场的结果中的新价值
    
    结果
    
    与指定的字段集的同一类型的对象，而不是空的
    
    异常
    
    DateTimeException -如果该字段不能设置
    
    UnsupportedTemporalTypeException如果字段不支持
    
    ArithmeticException如果数值溢出时
  - plus
```
default ChronoLocalDate plus(TemporalAmount amount)
```
    返回与此对象添加的相同类型的对象。
    这调整这个时间，添加根据指定金额的规则。量是一个典型的Period但可能是任何其他类型的实施TemporalAmount接口，如Duration。
    
    一些示例代码，说明如何以及为什么使用这种方法：
```
日期=日期（期间）；/ /添加一个周期实例日期。+（持续时间）；/ /添加一个持续时间实例日期=日期。加（工作日（6））；//实例用户编写的工作日的方法
```
    注意，调用plus随后minus不保证返回相同的日期时间。
    Specified by:
    
    plus 接口 Temporal
    
    参数
    
    amount -添加量，不为空
    
    结果
    
    同一类型的对象，所指定的调整，而不是空
    
    异常
    
    DateTimeException如果还不能
    
    ArithmeticException如果数值溢出时
  - plus
```
default ChronoLocalDate plus(long amountToAdd,
                             TemporalUnit unit)
```
    返回与此对象相同的类型的对象，添加指定的周期。
    此方法返回一个新的对象，在此基础上添加指定的周期。例如，在一个LocalDate，这可以用来添加一个数年、月或日。返回的对象将有相同的可观察的类型作为此对象。
    
    在某些情况下，改变一个字段没有完全定义。例如，如果目标对象是代表1月31日的日期，则添加一个月将不清楚。在这样的情况下，该字段负责解决结果。通常情况下，它会选择以前的有效日期，这将是二月的最后一个有效的一天，在这个例子中。
    
    Specified by:
    
    plus 接口 Temporal
    
    参数
    
    amountToAdd -添加指定的单位的数量，可能是负面的
    
    unit -期添加单元，不为空
    
    结果
    
    与指定的周期添加的相同类型的对象，而不是空的
    
    异常
    
    DateTimeException如果单位不能添加
    
    ArithmeticException如果数值溢出时
  - minus
```
default ChronoLocalDate minus(TemporalAmount amount)
```
    返回一个与此对象相同的类型的对象，该对象的金额减去。
    这调整这个时间，减去根据指定金额的规则。量是一个典型的Period但可能是任何其他类型的实施TemporalAmount接口，如Duration。
    
    一些示例代码，说明如何以及为什么使用这种方法：
```
日期=日期减去（期间）；/ /减去一个周期实例日期。减去（持续时间）；/ /减去持续时间实例日期=日期减去（工作日（6））；//实例用户编写的工作日的方法
```
    注意，调用plus随后minus不保证返回相同的日期时间。
    Specified by:
    
    minus 接口 Temporal
    
    参数
    
    amount -减去的量，不为空
    
    结果
    
    同一类型的对象，所指定的调整，而不是空
    
    异常
    
    DateTimeException如果减法不能做
    
    ArithmeticException如果数值溢出时
  - minus
```
default ChronoLocalDate minus(long amountToSubtract,
                              TemporalUnit unit)
```
    返回与指定期间减去的相同类型的对象。
    此方法返回一个新的对象，在此基础上减去指定的周期。例如，在一个LocalDate，这可以用来减去一个数年、月或日。返回的对象将有相同的可观察的类型作为此对象。
    
    在某些情况下，改变一个字段没有完全定义。例如，如果目标对象是代表3月31日的日期，那么减去一个月就不清楚了。在这样的情况下，该字段负责解决结果。通常情况下，它会选择以前的有效日期，这将是二月的最后一个有效的一天，在这个例子中。
    
    Specified by:
    
    minus 接口 Temporal
    
    参数
    
    amountToSubtract -减去指定的单位的数量，可能是负面的
    
    unit -期减去单位，不为空
    
    结果
    
    同一类型的对象与指定的周期中减去的，而不是空的
    
    异常
    
    DateTimeException如果单位不能扣除
    
    UnsupportedTemporalTypeException如果单位不支持
    
    ArithmeticException如果数值溢出时
  - query
```
default <R> R query(TemporalQuery<R> query)
```
    使用指定的查询查询此日期。
    此查询使用指定的查询策略对象查询此日期。的TemporalQuery对象定义了用来获得结果的逻辑。阅读查询的文档，了解该方法的结果将是什么。
    
    这种方法的结果是通过调用指定的查询通过this作为论据的TemporalQuery.queryFrom(TemporalAccessor)方法得到的。
    
    Specified by:
    
    query 接口 TemporalAccessor
    
    参数类型
    
    R -结果的类型
    
    参数
    
    query -调用查询，不空
    
    结果
    
    查询结果，可以返回（由查询所定义）
    
    异常
    
    DateTimeException如果无法查询（查询所定义）
    
    ArithmeticException如果数值溢出时（由查询定义）
  - adjustInto
```
default Temporal adjustInto(Temporal temporal)
```
    调整指定的时间对象，以具有此对象的相同日期。
    这将返回一个相同可观察类型的时间对象，因为输入的日期更改为与此相同的。
    
    调整是相当于用Temporal.with(TemporalField, long)传递ChronoField.EPOCH_DAY作为现场。
    
    在大多数情况下，更清晰的用Temporal.with(TemporalAdjuster)反向调用模式：
```
这两条线是等价的，但第二种方法是建议时间= thislocaldate adjustinto（时间）；时间=（thislocaldate）与时间；
```
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    adjustInto 接口 TemporalAdjuster
    
    参数
    
    temporal -调整目标对象，不为空
    
    结果
    
    调整后的对象，而不是空
    
    异常
    
    DateTimeException如果无法适应
    
    ArithmeticException如果数值溢出时
  - until
```
long until(Temporal endExclusive,
           TemporalUnit unit)
```
    计算时间的量，直到指定单元的另一个日期为止。
    这两ChronoLocalDate计算对象之间的时间量在一个TemporalUnit条款。开始和结束点this和指定的日期。结果将是负的，如果结束之前开始。的Temporal传递给此方法转换为ChronoLocalDate使用Chronology.date(TemporalAccessor)。计算返回一个整数，表示两个日期之间的完整单位数。例如，两个日期之间的天数的量可以计算出使用startDate.until(endDate, DAYS)。
    
    使用这种方法有两个等效的方法。首先是调用这个方法。二是用TemporalUnit.between(Temporal, Temporal)：
```
这两条线是等价的金额=开始，直到（结束，月）；金额=月间（开始，结束）；
```
    的选择应基于使得代码更易读。
    计算中实现该方法ChronoUnit。单位DAYS，WEEKS，MONTHS，YEARS，DECADES，CENTURIES，MILLENNIA和ERAS应该由所有实现支持。其他ChronoUnit值将抛出一个异常。
    
    如果单位不ChronoUnit，然后通过调用TemporalUnit.between(Temporal, Temporal) this作为第一个参数传递和转换的输入时间作为第二个参数给出了这个方法的结果。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    until 接口 Temporal
    
    参数
    
    endExclusive -结束日期，独家，并转换为在同一个时代 ChronoLocalDate，不空
    
    unit -单位量来衡量，不为空
    
    结果
    
    这个日期和结束日期之间的时间
    
    异常
    
    DateTimeException如果金额无法计算，或结束时间不能转换为 ChronoLocalDate
    
    UnsupportedTemporalTypeException如果单位不支持
    
    ArithmeticException如果数值溢出时
  - until
```
ChronoPeriod until(ChronoLocalDate endDateExclusive)
```
    计算这个日期和日期之间的时间作为一个 ChronoPeriod。
    这计算两个日期之间的周期。所有提供的年表计算使用年期、月和日，但ChronoPeriod API允许期间要使用其他单位代表。
    
    开始和结束点this和指定的日期。结果将是负的，如果结束之前开始。在每一年，一个月和一天，消极的标志会是一样的。
    
    使用此日期的时间顺序进行计算。如果有必要，输入日期将被转换为匹配。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    endDateExclusive -结束日期，独家的，这可能是在任何年代，不空
    
    结果
    
    这个日期和结束日期之间的期间，而不是空
    
    异常
    
    DateTimeException -如果时间不能计算
    
    ArithmeticException如果数值溢出时
  - format
```
default String format(DateTimeFormatter formatter)
```
    使用指定的格式的日期格式。
    该日期将被传递到格式化程序产生一个字符串。
    
    默认实现必须表现如下：
```
返回格式化格式（这）；
```
    参数
    
    formatter -格式化程序使用，不为空
    
    结果
    
    格式化的日期字符串，而不是空的
    
    异常
    
    DateTimeException如果打印时发生错误
  - atTime
```
default ChronoLocalDateTime<?> atTime(LocalTime localTime)
```
    结合这个日期与时间创建一个 ChronoLocalDateTime。
    这会返回一个由这个日期在指定的时间ChronoLocalDateTime。日期和时间的所有可能的组合都是有效的。
    
    参数
    
    localTime -使用本地时间，不是空的
    
    结果
    
    从这个日期和指定时间形成的本地日期时间，而不是空
  - toEpochDay
```
default long toEpochDay()
```
    将此日期转换为新纪元日。
    是一个简单的Epoch Day count递增计数的日子，0天是1970-01-01（ISO）。这个定义是所有年表一样，使转换。
    
    此默认实现查询EPOCH_DAY场。
    
    结果
    
    这个日期的时代相当于这个日期
  - compareTo
```
default int compareTo(ChronoLocalDate other)
```
    将此日期与另一个日期进行比较，包括年代。
    比较是基于第一个基本的时间线日期，然后在年代。这是“等于”一致，所定义的Comparable。
    
    例如，下面是比较器的顺序：
    1. 2012-12-03 (ISO)
    2. 2012-12-04 (ISO)
    3. 2555-12-04 (ThaiBuddhist)
    4. 2012-12-05 (ISO)
    值2和3 # #代表时间线相同的日期。当两个值表示相同的日期时，将该时间顺序标识进行比较以区分它们。这一步是必要的，使排序“一致的等于”。
    如果所有的日期对象进行比较都在同一个时间段，那么额外的时间段阶段是不需要的，只有本地日期使用。比较两TemporalAccessor实例的日期，包括在两个不同的年表的日期，使用ChronoField.EPOCH_DAY作为比较器。
    
    此默认实现执行以上定义的比较。
    Specified by:
    
    compareTo 接口 Comparable<ChronoLocalDate>
    
    参数
    
    other -其他日期进行比较，不为空
    
    结果
    
    比较器的值，负的，如果少，积极的，如果更大
  - isAfter
```
default boolean isAfter(ChronoLocalDate other)
```
    检查此日期是否在指定日期后忽略了时间顺序。
    这种方法不同于在compareTo(java.time.chrono.ChronoLocalDate)在比较，只是比较底层的日期而不是年表。这允许在不同的日历系统中的日期进行比较的基础上的时间线位置。这相当于使用date1.toEpochDay() > date2.toEpochDay()。
    
    此默认实现执行基于“划时代”的比较。
    
    参数
    
    other -其他日期进行比较，不为空
    
    结果
    
    如果这是在指定日期之后
  - isBefore
```
default boolean isBefore(ChronoLocalDate other)
```
    检查此日期是否在指定日期之前忽略了时间顺序。
    这种方法不同于在compareTo(java.time.chrono.ChronoLocalDate)在比较，只是比较底层的日期而不是年表。这允许在不同的日历系统中的日期进行比较的基础上的时间线位置。这相当于使用date1.toEpochDay() < date2.toEpochDay()。
    
    此默认实现执行基于“划时代”的比较。
    
    参数
    
    other -其他日期进行比较，不为空
    
    结果
    
    这是真的，如果这是在指定日期之前
  - isEqual
```
default boolean isEqual(ChronoLocalDate other)
```
    检查此日期是否等于指定日期忽略了时间顺序。
    这种方法不同于在compareTo(java.time.chrono.ChronoLocalDate)在比较，只是比较底层的日期而不是年表。这允许在不同的日历系统中的日期进行比较的基础上的时间线位置。这相当于使用date1.toEpochDay() == date2.toEpochDay()。
    
    此默认实现执行基于“划时代”的比较。
    
    参数
    
    other -其他日期进行比较，不为空
    
    结果
    
    如果基本日期等于指定日期，则为
  - equals
```
boolean equals(Object obj)
```
    检查这个日期是否等于另一个日期，包括年代。
    将此日期与另一个确保日期和时间的日期是相同的。
    
    比较两TemporalAccessor实例的日期，包括在两个不同的年表的日期，使用ChronoField.EPOCH_DAY作为比较器。
    
    重写：
    
    equals 方法重写，继承类 Object
    
    参数
    
    obj -对象检查，空返回false
    
    结果
    
    如果这是等于另一日期
    
    另请参见：
    
    Object.hashCode()， HashMap
  - hashCode
```
int hashCode()
```
    此日期的哈希代码。
    
    重写：
    
    hashCode 方法重写，继承类 Object
    
    结果
    
    一个合适的哈希代码
    
    另请参见：
    
    Object.equals(java.lang.Object)， System.identityHashCode(java.lang.Object)
  - toString
```
String toString()
```
    输出这个日期作为一个
    输出将包括完整的本地日期。
    String。
    
    重写：
    
    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.

Interface ChronoLocalDate

何时使用此接口

建筑问题要考虑

在多日历系统代码中导致错误的错误假设

使用localdate相反

方法摘要

Methods inherited from interface java.time.temporal.TemporalAccessor

方法详细信息

timeLineOrder

from

getChronology

getEra

isLeapYear

lengthOfMonth

lengthOfYear

isSupported

isSupported

with

with

plus

plus

minus

minus

query

adjustInto

until

until

format

atTime

toEpochDay

compareTo

isAfter

isBefore

isEqual

equals

hashCode

toString