Excelentes perguntas, vou tentar responder e se ficarem dúvidas por favor me diga.
Quanto a "ponto no tempo" quis dizer que são classes que marcam um determinado periodo de tempo em uma linha do tempo, de X a Y e não uma data avulsa, mas confesso que relendo e pensando fiquei intrigado e vou melhorar os textos atualizando eles para ser mais claro a respeito, muito obrigado pelo feedback ^^.
Agora quato a ChronoUnit e ChronoField:
ChronoUnit é uma enumeração que representa unidades de tempo padrão, como anos, meses, dias, horas, minutos, segundos, entre outros. É usada para realizar cálculos entre datas e períodos, como adicionar ou subtrair uma quantidade específica de unidades de tempo a uma data, por exemplo:
LocalDate.now().plus(3, ChronoUnit.MONTHS)
Isso adicionará 3 meses à data atual.
ChronoField é uma enumeração que representa campos específicos de uma data ou hora, como ano, mês, dia do mês, hora, minuto, segundo, entre outros. É utilizada para acessar e manipular os valores individuais desses campos em uma data ou hora. Por exemplo:
LocalDate.now().get(ChronoField.YEAR)
Isso retorna o ano atual da data.
ChronoUnit é usado para cálculos entre datas, enquanto ChronoField é usado para acessar e manipular componentes específicos da data ou hora.
Opa, muito obrigado pela explicação do que significa um ponto no tempo e uma data, clareou a mente. Um tem conhecimento do todo (a linha do tempo) e o significado de si mesmo neste todo, o outro nem sequer conhece o todo ou se identifica nele.
Agora sobre ChronoUnit e ChronoField específicamente, o cálculo em si não seria uma forma de acessar e manipular data ou hora? Fazendo ambos, necessariamente, ter o mesmo objetivo?
E referente a nomenclatura "unidade de tempo padrão" e "campos específicos de uma data ou hora" me parecem muito apenas mudar o nome para o que, em resultado, é a mesma coisa, ambos são enumerações que contém anos, meses, dias, horas, etc. Com a adição do ChronoField ter um detalhamento ainda maior tendo os dias no mes, semanas do ano, etc. Ou seja, um fazendo exatamente a mesma coisa que o outro só que com mais enriquecimento de detalhes. (Apesar de parecer uma afirmação, é só uma tentativa de explicar a minha linha de raciocínio que, inclusive, está me confundindo)
* This set of fields provide field-based access to manipulate a date, time or date-time. * The standard set of fields can be extended by implementing {@link TemporalField}. *
* These fields are intended to be applicable in multiple calendar systems. * For example, most non-ISO calendar systems define dates as a year, month and day, * just with slightly different rules. * The documentation of each field explains how it operates. * * @implSpec * This is a final, immutable and thread-safe enum. * * @since 1.8 */ public enum ChronoField implements TemporalField { ``` ```java /** * A standard set of date periods units. *
* This set of units provide unit-based access to manipulate a date, time or date-time. * The standard set of units can be extended by implementing {@link TemporalUnit}. *
* These units are intended to be applicable in multiple calendar systems. * For example, most non-ISO calendar systems define units of years, months and days, * just with slightly different rules. * The documentation of each unit explains how it operates. * * @implSpec * This is a final, immutable and thread-safe enum. * * @since 1.8 */ public enum ChronoUnit implements TemporalUnit { ``` A `ChronoField` é um "conjunto de campos padrão" e `ChronoUnit` é descrita como "um conjunto padrão de unidades de período de datas". De fato por descrição são praticamente a mesma coisa. Mas vamos imaginar que eu quero somar 10 dias na data atual, eu faria algo mais ou menos assim: ```java LocalDate value = LocalDate.now().plus(10, ChronoUnit.DAYS); ``` Como a assinatura do método `plus()` espera receber um `TemporalAmount` ou um valor inteiro e um `TemporalUnit` então só é possível utilizar `ChronoUnit` que implementa a interface (é um) `TemporalUnit`. Da mesma forma, vamos dizer que eu queira saber em que mês estamos, eu teria de fazer ```java LocalDate.now().get(ChronoField.MONTH_OF_YEAR); ``` Nesse caso o método `get()` espera receber um `TemporalField`, logo não é possível utilizar `ChronoUnit` e por isso utilizamos `ChronoField` que implementa a interface (é um) `TemporalField`. Quanto a semântica, penso o seguinte: **ChronoUnit** Uma unidade deve ser utilizada para medir uma quantidade de tempo - anos, meses, dias, horas, minutos, segundos. Por exemplo, o segundo é uma unidade do S.I. **ChronoField** Por outro lado, os campos são como os humanos geralmente se referem ao tempo, que é em partes. Se você olhar para um relógio digital, os segundos contam de 0 a 59 e depois voltam para 0 novamente. Este é um campo - "segundo do minuto" neste caso, formado pela contagem de segundos dentro de um minuto. Da mesma forma, os dias são contados dentro de um mês e os meses dentro de um ano. Para definir um ponto completo na linha do tempo, você precisa ter um conjunto de campos vinculados, por exemplo: - segundo de minuto - minuto-a-hora - hora do dia - dia do mês - mês do ano - ano (-de-para-sempre) A API ChronoField expõe as duas partes do segundo do minuto.Podemos utilizar `getBaseUnit()` para obter "segundos" e `getRangeUnit()` para obter "minutos". A parte Chrono do nome refere-se ao fato de que as definições são cronologicamente neutras. Especificamente, isso significa que a unidade ou campo tem significado apenas quando associado a um sistema de calendário ou cronologia. Um exemplo disso é a cronologia copta, onde há 13 meses em um ano. Apesar de ser diferente do sistema de calendário civil/ISO comum, a constante ChronoField.MONTH_OF_YEAR ainda pode ser usada. As interfaces TemporalUnit e TemporalField fornecem a abstração de nível mais alto, permitindo que unidades/campos que não são cronologicamente neutros sejam adicionados e processados. Não sei se ficou mais claro ou mais confuso, mas pelo menos acho que eu entendi melhor um pouco sobre essa duas enums e sua utilização. Penso que talvez pudessem ter feito uma única enum pra tudo, porém acredito que tiverem alguns motivos pra ter as duas, sendo o primeiro deles querer separar unidades de campos para que aquele que lê o código possa entender mais rapidamente do que se trata aquele código.